@cdmbase/ai-sdk-provider-cdecli

AI SDK v6 provider that talks to a cdecli agent's HTTP server (cdecli serve). Conversation state is kept server-side per session_id; the provider only sends the latest user turn.

Install

yarn add @cdmbase/ai-sdk-provider-cdecli ai

Configure

The cdecli agent runs as a pod (e.g. yantra-aistack-cdecli-agent-0 in main-system) and is typically reached through an ingress:

# Production (yantra-stack)
export CDECLI_BASE_URL="https://cdecli-agent.cdebase.dev"
export CDECLI_TOKEN="<bearer-token>"

# Local dev — `cdecli agent serve --port 8090`
export CDECLI_BASE_URL="http://localhost:8090"

The provider also accepts yantra-stack's existing variable names as fallbacks: CDECLI_AGENT_ENDPOINT (URL) and CDECLI_AGENT_TOKEN (bearer).

For in-cluster port-forwarding during dev:

kubectl port-forward -n main-system pod/$(kubectl get pods -n main-system \
  -o name | grep cdecli | head -n1 | cut -d/ -f2) 8080:8080
export CDECLI_BASE_URL="http://127.0.0.1:8080"

Use with @cdmbase/agent-kit

@cdmbase/agent-kit (a fork of inngest/agent-kit) lets you build multi-agent networks with deterministic routing. Pass the cdecli provider as the model for any agent, or as the defaultModel for the whole network.

yarn add @cdmbase/agent-kit @cdmbase/ai-sdk-provider-cdecli inngest

Single agent

import { createAgent, createNetwork } from "@cdmbase/agent-kit";
import { createCdecli } from "@cdmbase/ai-sdk-provider-cdecli";

const cdecli = createCdecli({
  // defaults to CDECLI_BASE_URL / CDECLI_AGENT_ENDPOINT env vars
  defaultSettings: { skill: "support" },
});

const supportAgent = createAgent({
  name: "support",
  description: "Answers customer questions using 960+ Yantra connectors.",
  system: "You are a helpful support agent.",
  model: cdecli("default"), // "default" → server picks GPT-4o
});

const network = createNetwork({
  name: "support-network",
  agents: [supportAgent],
});

const { output } = await network.run(
  "My order #42 hasn't shipped — what's going on?"
);
console.log(output);

Multi-agent network with routing

import { createAgent, createNetwork, createRoutingAgent, createTool } from "@cdmbase/agent-kit";
import { createCdecli } from "@cdmbase/ai-sdk-provider-cdecli";
import { z } from "zod";

const cdecli = createCdecli();

// Triage agent — picks the right specialist
const triageAgent = createAgent({
  name: "triage",
  system: "Classify the request and route to 'billing' or 'technical'.",
  model: cdecli("default"),
  tools: [
    createTool({
      name: "route",
      description: "Route the request to the appropriate team",
      parameters: z.object({ team: z.enum(["billing", "technical"]) }),
      handler: async ({ team }, { network }) => {
        network?.state.kv.set("team", team);
      },
    }),
  ],
});

const billingAgent = createAgent({
  name: "billing",
  system: "You handle billing and payment issues.",
  model: cdecli("default", { skill: "billing" }),
});

const technicalAgent = createAgent({
  name: "technical",
  system: "You handle technical and product issues.",
  model: cdecli("default", { skill: "technical" }),
});

const network = createNetwork({
  name: "support",
  agents: [triageAgent, billingAgent, technicalAgent],
  defaultModel: cdecli("default"),
  router: ({ network }) => {
    const team = network?.state.kv.get("team") as string | undefined;
    if (!team) return triageAgent;
    return network?.agents.get(team);
  },
});

const { output } = await network.run("I was charged twice last month.");
console.log(output);

With session persistence (cross-call memory)

const cdecli = createCdecli();

const agent = createAgent({
  name: "assistant",
  system: "You are a helpful assistant with memory.",
  // Passing a stable sessionId reuses the server-side conversation history
  model: cdecli("default", { sessionId: `user-${userId}` }),
});

Use with AI SDK directly

import { generateText, streamText } from "ai";
import { createCdecli } from "@cdmbase/ai-sdk-provider-cdecli";

const cdecli = createCdecli({
  // baseUrl + authToken default to env vars
  defaultSettings: { skill: "general" },
});

const { text } = await generateText({
  model: cdecli("anthropic/claude-sonnet-4-5"),
  prompt: "Summarize what cdecli does.",
});

const { textStream } = await streamText({
  model: cdecli("anthropic/claude-sonnet-4-5"),
  prompt: "Stream a haiku.",
});
for await (const chunk of textStream) process.stdout.write(chunk);

Options

| Option | Default | Notes | | ----------------- | ------------------------------------------------------------------ | ------------------------------------------ | | baseUrl | CDECLI_BASE_URL → CDECLI_AGENT_ENDPOINT | cdecli serve URL | | authToken | CDECLI_TOKEN → CDECLI_AGENT_TOKEN → CDECLI_AUTH_TOKEN | Bearer token | | timeoutMs | 120_000 | Per-request timeout | | fetch | global fetch | Override for testing/proxies | | defaultSettings | — | { sessionId?, skill?, skillId?, local? } |

Per-call settings can be supplied as cdecli(modelId, { skill, skillId, local, sessionId }).

Limitations

• temperature, topP, topK, seed, maxOutputTokens, etc. are reported as unsupported warnings — cdecli decides them server-side.
• Client-supplied tools are ignored; tools run inside cdecli.
• Token usage is not reported (cdecli does not surface counts today).