@cognition-ai/sdk

bun add @cognition-ai/sdk@beta   # or: npm i @cognition-ai/sdk@beta

import { createDevin, type DevinClient } from "@cognition-ai/sdk";

await using devin = await createDevin(); // CloudDevin, apiKey from DEVIN_API_KEY
const cloud = await createDevin({ apiKey }); // CloudDevin
const local = await createDevin({ cwd: process.cwd() }); // LocalDevin

async function run(devin: DevinClient, prompt: string) {
  const session = await devin.createSession();
  return session.send(prompt);
}

import { createDevin } from "@cognition-ai/sdk";

const devin = await createDevin({ apiKey }); // CloudDevin — `api` is cloud-only

const session = await devin.api.sessions.getSession({
  org_id: "org_…",
  devin_id: "devin-…",
});
console.log(session.status_detail, session.structured_output, session.pull_requests);

await devin.api.playbooks.listPlaybooks({ org_id: "org_…" });

import { LocalDevin } from "@cognition-ai/sdk";

const local = await LocalDevin.start({
  cwd: "/path/to/project",
  // Permission requests (e.g. running shell commands) are rejected unless handled.
  onPermission: (request) => {
    console.log(request.toolCall.title);
    return "allow";
  },
});

const session = await local.createSession();

// Stream the turn's typed events (message/thought deltas, tool calls, plans)…
for await (const event of session.stream("Fix the failing test in src/utils")) {
  if (event.type === "message_delta") process.stdout.write(event.text);
  if (event.type === "tool_call") console.log(event.call.title, event.call.status);
}

// …or just wait for the result.
const result = await session.send("Now run the test suite");
console.log(result.stopReason, result.usage);

local.close();

import { CognitionExtensionMethod, isExtension } from "@cognition-ai/sdk";

session.onExtension = (notification) => {
  if (isExtension(notification, CognitionExtensionMethod.AgentStopped)) {
    console.log(notification.cause, notification.stats);
  }
};

import { Fusion } from "@cognition-ai/sdk";

const session = await local.createSession();
const models = session.models();
console.log(models?.current); // "swe-2-high"
console.log(models?.options.filter((m) => m.id.startsWith("fusion-")).map((m) => m.id));

await session.setModel(Fusion({ leader: "claude-opus-5-max", sidekick: "swe-2-high" }));
await session.setModel("fusion-adaptive"); // let Fusion pick the pairing

Fusion({ leader: "claude-opus-5-max", sidekick: "swe-2-high" }).id;
// "fusion-claude-opus-5-max-sidekick-swe-2-high"

import { CloudDevin } from "@cognition-ai/sdk";

const cloud = await CloudDevin.connect({ orgId: "org_…" }); // apiKey from DEVIN_API_KEY

const session = await cloud.createSession();
const result = await session.send("Summarize the open PRs in this repo");
console.log(result.stopReason);

// Resume an existing cloud session by id.
const { session: resumed, replay } = await cloud.loadSession("devin-…");

// Platform operations go through the generated v3 client.
await cloud.api.sessions.getSessions({ org_id: "org_…" });

cloud.close();

const session = await cloud.attach("devin-…"); // no onPermission: observers don't decide
for await (const event of session.events()) {
  switch (event.type) {
    case "status": // working / blocked / finished, with what the user must do
      console.log(event.status, event.userActionRequired ?? event.message);
      break;
    case "pull_request": // a PR attached to the session changed; refetch
      console.log(event.prUrl);
      break;
    case "plan": // what is left to do
      console.log(event.entries.filter((e) => e.status !== "completed"));
  }
}

npm install @opentelemetry/api @opentelemetry/sdk-trace-base @langfuse/otel

import { LangfuseSpanProcessor } from "@langfuse/otel";
import { BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
import { createDevin } from "@cognition-ai/sdk";
import { traceSessions } from "@cognition-ai/sdk/tracing";

// Reads LANGFUSE_PUBLIC_KEY, LANGFUSE_SECRET_KEY and LANGFUSE_BASE_URL.
const provider = new BasicTracerProvider({ spanProcessors: [new LangfuseSpanProcessor()] });

const devin = await createDevin({
  cwd: "/path/to/project", // omit for CloudDevin
  tracing: traceSessions({ tracer: provider.getTracer("my-app"), userId: "user-123" }),
});

const session = await devin.createSession({ tracing: { metadata: { taskId: "task-42" } } });
await session.run("Fix the failing test in src/utils");

devin.close(); // ends any unfinished turn
await provider.shutdown(); // flushes pending spans

import { traceSession } from "@cognition-ai/sdk/tracing";

const tracer = traceSession(session, { tracer: provider.getTracer("my-app") });
tracer.recordPrompt(prompt);
await session.send(prompt);
await tracer.end(); // ends an unfinished turn

bun run generate