@flint-dev/sdk 0.2.0

package/README.md

@@ -0,0 +1,288 @@
+# @flint-dev/sdk
+
+Client library for Flint app servers and the Flint gateway.
+
+It includes:
+
+- `AppServerClient` / `createClient(...)` for Codex-style app server protocol over stdio.
+- `GatewayClient` for HTTP calls to the Flint gateway (`/v1/threads` APIs).
+
+## Install
+
+```bash
+bun add @flint-dev/sdk
+```
+
+Then install the app server for the provider you want to use:
+
+```bash
+bun add @flint-dev/claude-app-server  # Claude (Anthropic)
+bun add @flint-dev/pi-app-server      # Pi (multi-provider)
+```
+
+## Quick start (app server)
+
+```ts
+import { createClient } from "@flint-dev/sdk";
+
+const client = createClient({ provider: "claude", cwd: process.cwd() });
+await client.start();
+await client.createThread();
+
+for await (const event of client.prompt("Explain this codebase")) {
+  switch (event.type) {
+    case "text":
+      process.stdout.write(event.delta);
+      break;
+    case "tool_start":
+      console.log(`\n[${event.name}]`);
+      break;
+    case "tool_end":
+      console.log(event.isError ? "[failed]" : "[done]");
+      break;
+    case "error":
+      console.error(event.message);
+      break;
+  }
+}
+
+client.close();
+```
+
+## Quick start (gateway HTTP)
+
+```ts
+import { GatewayClient } from "@flint-dev/sdk";
+
+const gateway = new GatewayClient({ baseUrl: "http://127.0.0.1:8788" });
+
+const created = await gateway.createThread({
+  channel: "slack",
+  userId: "u1",
+  text: "Summarize the backlog",
+});
+
+const followup = await gateway.sendThreadMessage(created.threadId, "Now draft next steps");
+console.log(followup.reply);
+```
+
+## Providers
+
+A provider resolves to the command and arguments needed to spawn an app server. Three are built in:
+
+| Name       | App server                         | Default model             |
+| ---------- | ---------------------------------- | ------------------------- |
+| `"claude"` | `@flint-dev/claude-app-server`         | `claude-opus-4-6`         |
+| `"pi"`     | `@flint-dev/pi-app-server`             | `google/gemini-2.5-flash` |
+| `"codex"`  | `codex app-server` (system binary) | —                         |
+
+```ts
+// Use a built-in provider
+const client = createClient({ provider: "pi", cwd: process.cwd() });
+```
+
+### Custom providers
+
+Register your own provider to point at any Codex-protocol-compatible server:
+
+```ts
+import { registerProvider, createClient } from "@flint-dev/sdk";
+
+registerProvider("my-server", {
+  resolve(config) {
+    return {
+      command: "my-app-server",
+      args: ["--cwd", config.cwd],
+      cwd: config.cwd,
+      env: config.env,
+    };
+  },
+});
+
+const client = createClient({ provider: "my-server", cwd: process.cwd() });
+```
+
+### Manual configuration
+
+Skip providers entirely and pass spawn options directly:
+
+```ts
+import { AppServerClient } from "@flint-dev/sdk";
+
+const client = new AppServerClient({
+  command: "bun",
+  args: ["run", "./my-server/index.ts"],
+  cwd: process.cwd(),
+  env: { MY_API_KEY: "..." },
+});
+```
+
+## API
+
+### `createClient(options): AppServerClient`
+
+Factory that resolves a provider name to spawn configuration.
+
+```ts
+type CreateClientOptions =
+  | { provider: string; cwd: string; env?: Record<string, string> }
+  | AppServerClientOptions;
+```
+
+### `AppServerClient`
+
+#### `new AppServerClient(options)`
+
+```ts
+interface AppServerClientOptions {
+  command: string;
+  args?: string[];
+  cwd: string;
+  env?: Record<string, string>;
+}
+```
+
+#### `client.start(): Promise<void>`
+
+Spawns the app server process and sends the `initialize` handshake.
+
+#### `client.createThread(options?): Promise<string>`
+
+Creates a new conversation thread. Returns the thread ID.
+
+```ts
+interface CreateThreadOptions {
+  model?: string;
+}
+```
+
+#### `client.prompt(text, options?): AsyncGenerator<AgentEvent>`
+
+Sends a prompt and yields events as they stream back. Automatically creates a thread if one hasn't been created yet.
+
+```ts
+interface PromptOptions {
+  model?: string;
+}
+```
+
+#### `client.interrupt(): Promise<void>`
+
+Interrupts the current turn.
+
+#### `client.close(): void`
+
+Kills the app server process.
+
+### `GatewayClient`
+
+```ts
+new GatewayClient({
+  baseUrl: string,
+  headers?: HeadersInit,
+  fetch?: typeof fetch,
+});
+```
+
+#### `gateway.health(): Promise<GatewayHealth>`
+
+Calls `GET /v1/health`.
+
+#### `gateway.listThreads(): Promise<GatewayThreadRecord[]>`
+
+Calls `GET /v1/threads`.
+
+#### `gateway.getThread(threadId): Promise<GatewayThreadRecord | undefined>`
+
+Calls `GET /v1/threads/:threadId`. Returns `undefined` on 404.
+
+#### `gateway.createThread(payload, idempotencyKey?): Promise<GatewayReply>`
+
+Calls `POST /v1/threads`.
+
+#### `gateway.sendThreadMessage(threadId, payloadOrText, idempotencyKey?): Promise<GatewayReply>`
+
+Calls `POST /v1/threads/:threadId`.
+
+#### `gateway.interruptThread(threadId): Promise<boolean>`
+
+Calls `POST /v1/threads/:threadId/interrupt`. Returns `false` when gateway reports no active runtime (`409`).
+
+#### `GatewayHttpError`
+
+Thrown for non-2xx responses (except handled `404`/`409` cases above). Includes:
+
+- `status`: HTTP status code
+- `body`: parsed JSON response body when available
+
+### `AgentEvent`
+
+```ts
+type AgentEvent =
+  | { type: "text"; delta: string }
+  | { type: "reasoning"; delta: string }
+  | { type: "tool_start"; id: string; name: string; input?: unknown }
+  | { type: "tool_end"; id: string; result?: unknown; isError: boolean }
+  | { type: "done"; usage?: { input: number; output: number } }
+  | { type: "error"; message: string };
+```
+
+| Event        | Description                                                        |
+| ------------ | ------------------------------------------------------------------ |
+| `text`       | Streamed text token from the agent                                 |
+| `reasoning`  | Streamed reasoning/thinking token                                  |
+| `tool_start` | Agent began using a tool (`Bash`, `Edit`, `Write`, or an MCP tool) |
+| `tool_end`   | Tool execution finished                                            |
+| `done`       | Turn completed                                                     |
+| `error`      | Turn failed                                                        |
+
+## Local development
+
+To use the SDK from a local checkout of the flint repo without publishing to npm:
+
+### bun link
+
+Symlinks packages globally, then into your project. Best for active development since changes are reflected immediately.
+
+```bash
+# Register the packages (run once from the flint repo)
+cd packages/sdk && bun link
+cd packages/app-server && bun link          # if using Claude
+cd packages/pi-app-server && bun link       # if using Pi
+
+# Link them into your project
+cd ~/my-app
+bun link @flint-dev/sdk
+bun link @flint-dev/claude-app-server           # or @flint-dev/pi-app-server
+```
+
+### file: dependencies
+
+Point at the local packages directly in your `package.json`:
+
+```json
+{
+  "dependencies": {
+    "@flint-dev/sdk": "file:../flint/packages/sdk",
+    "@flint-dev/claude-app-server": "file:../flint/packages/app-server"
+  }
+}
+```
+
+Then run `bun install`.
+
+### bun pack
+
+Creates a tarball, which is the closest to what `npm publish` actually produces. Useful for verifying the package is correctly configured before publishing.
+
+```bash
+cd packages/sdk && bun pack
+# => flint-sdk-0.1.0.tgz
+
+cd ~/my-app
+bun add ../flint/packages/sdk/flint-sdk-0.1.0.tgz
+```
+
+## Requirements
+
+- [Bun](https://bun.sh) runtime

package/dist/app-server-client.d.ts

@@ -0,0 +1,84 @@
+/**
+ * App Server Client
+ *
+ * Spawns an app-server-compatible child process and communicates
+ * over stdio using JSON-RPC 2.0. Translates app-server notifications
+ * to AgentEvent for TUI consumption.
+ */
+import type { AgentEvent } from "./types";
+export interface AppServerClientOptions {
+    /** Command to spawn the app server */
+    command: string;
+    /** Arguments to pass to the command */
+    args?: string[];
+    /** Working directory for the app server and Claude SDK */
+    cwd: string;
+    /** Environment variables for the app server process */
+    env?: Record<string, string>;
+}
+export interface CreateThreadOptions {
+    /** Model to use for the thread (e.g. "claude-sonnet-4-5-20250929") */
+    model?: string;
+    /** Optional provider-specific system prompt override */
+    systemPrompt?: string;
+    /** Optional MCP server config (provider-specific) */
+    mcpServers?: Record<string, unknown>;
+}
+export interface PromptOptions {
+    /** Model override for this turn */
+    model?: string;
+}
+export interface ResumeThreadOptions {
+    /** Override working directory when resuming */
+    cwd?: string;
+    /** Override model when resuming */
+    model?: string;
+    /** Optional MCP server config (provider-specific) */
+    mcpServers?: Record<string, unknown>;
+}
+export declare class AppServerClient {
+    private stdin;
+    private stdout;
+    private stderr;
+    private proc;
+    private nextId;
+    private pendingRequests;
+    private notificationListeners;
+    private buffer;
+    private stderrBuffer;
+    private stderrHistory;
+    private isClosing;
+    private initialized;
+    private threadId;
+    private currentTurnId;
+    private readonly command;
+    private readonly args;
+    private readonly cwd;
+    private readonly env;
+    constructor(options: AppServerClientOptions);
+    /** Start the app server process and initialize it. */
+    start(): Promise<void>;
+    /** Create a new thread. Returns the thread ID. */
+    createThread(options?: CreateThreadOptions): Promise<string>;
+    /** Resume an existing thread. Returns the thread ID. */
+    resumeThread(threadId: string, options?: ResumeThreadOptions): Promise<string>;
+    /** Get the active thread ID (if any). */
+    getThreadId(): string | null;
+    /** Send a prompt and yield AgentEvents as they stream in. */
+    prompt(prompt: string, options?: PromptOptions): AsyncGenerator<AgentEvent>;
+    /** Interrupt the current turn. */
+    interrupt(): Promise<void>;
+    /** Stop the app server process. */
+    close(): void;
+    private request;
+    private notify;
+    private readStdout;
+    private readStderr;
+    private pushStderrLine;
+    private stderrTail;
+    private watchProcessExit;
+    private handleMessage;
+    /** Translate app-server JSON-RPC notifications to AgentEvents. */
+    private translateNotification;
+}
+//# sourceMappingURL=app-server-client.d.ts.map

package/dist/app-server-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-server-client.d.ts","sourceRoot":"","sources":["../src/app-server-client.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAqB1C,MAAM,WAAW,sBAAsB;IACrC,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ,uDAAuD;IACvD,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,aAAa;IAC5B,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,+CAA+C;IAC/C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,MAAM,CAA2C;IACzD,OAAO,CAAC,MAAM,CAA2C;IACzD,OAAO,CAAC,IAAI,CAA6C;IACzD,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,eAAe,CAGnB;IACJ,OAAO,CAAC,qBAAqB,CAA0D;IACvF,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAuB;IACvC,OAAO,CAAC,aAAa,CAAuB;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAW;IAChC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAqC;gBAE7C,OAAO,EAAE,sBAAsB;IAO3C,sDAAsD;IAChD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAgC5B,kDAAkD;IAC5C,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAWlE,wDAAwD;IAClD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAWpF,yCAAyC;IACzC,WAAW,IAAI,MAAM,GAAG,IAAI;IAI5B,6DAA6D;IACtD,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,cAAc,CAAC,UAAU,CAAC;IAuDlF,kCAAkC;IAC5B,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAYhC,mCAAmC;IACnC,KAAK,IAAI,IAAI;YAqBC,OAAO;IAoBrB,OAAO,CAAC,MAAM;YASA,UAAU;YA4BV,UAAU;IA8BxB,OAAO,CAAC,cAAc;IActB,OAAO,CAAC,UAAU;YAIJ,gBAAgB;IAgB9B,OAAO,CAAC,aAAa;IA8BrB,kEAAkE;IAClE,OAAO,CAAC,qBAAqB;CA6H9B"}

package/dist/app-server-client.js

@@ -0,0 +1,431 @@
+/**
+ * App Server Client
+ *
+ * Spawns an app-server-compatible child process and communicates
+ * over stdio using JSON-RPC 2.0. Translates app-server notifications
+ * to AgentEvent for TUI consumption.
+ */
+export class AppServerClient {
+    stdin = null;
+    stdout = null;
+    stderr = null;
+    proc = null;
+    nextId = 1;
+    pendingRequests = new Map();
+    notificationListeners = [];
+    buffer = "";
+    stderrBuffer = "";
+    stderrHistory = [];
+    isClosing = false;
+    initialized = false;
+    threadId = null;
+    currentTurnId = null;
+    command;
+    args;
+    cwd;
+    env;
+    constructor(options) {
+        this.command = options.command;
+        this.args = options.args ?? [];
+        this.cwd = options.cwd;
+        this.env = options.env;
+    }
+    /** Start the app server process and initialize it. */
+    async start() {
+        this.isClosing = false;
+        const proc = Bun.spawn([this.command, ...this.args], {
+            stdin: "pipe",
+            stdout: "pipe",
+            stderr: "pipe",
+            cwd: this.cwd,
+            ...(this.env && { env: { ...process.env, ...this.env } }),
+        });
+        this.proc = proc;
+        this.stdin = proc.stdin;
+        this.stdout = proc.stdout;
+        this.stderr = proc.stderr;
+        // Read stdout in background
+        this.readStdout();
+        this.readStderr();
+        this.watchProcessExit(proc);
+        // Initialize the server
+        await this.request("initialize", {
+            clientInfo: {
+                name: "flint-tui",
+                version: "0.1.0",
+            },
+        });
+        // Send initialized notification (Codex protocol)
+        this.notify("initialized");
+        this.initialized = true;
+    }
+    /** Create a new thread. Returns the thread ID. */
+    async createThread(options) {
+        const result = (await this.request("thread/start", {
+            cwd: this.cwd,
+            ...(options?.model && { model: options.model }),
+            ...(options?.systemPrompt && { systemPrompt: options.systemPrompt }),
+            ...(options?.mcpServers && { mcpServers: options.mcpServers }),
+        }));
+        this.threadId = result.thread.id;
+        return this.threadId;
+    }
+    /** Resume an existing thread. Returns the thread ID. */
+    async resumeThread(threadId, options) {
+        const result = (await this.request("thread/resume", {
+            threadId,
+            ...(options?.cwd && { cwd: options.cwd }),
+            ...(options?.model && { model: options.model }),
+            ...(options?.mcpServers && { mcpServers: options.mcpServers }),
+        }));
+        this.threadId = result.thread.id;
+        return this.threadId;
+    }
+    /** Get the active thread ID (if any). */
+    getThreadId() {
+        return this.threadId;
+    }
+    /** Send a prompt and yield AgentEvents as they stream in. */
+    async *prompt(prompt, options) {
+        if (!this.threadId) {
+            await this.createThread();
+        }
+        // Set up notification listener before sending request
+        const events = [];
+        let resolve = null;
+        let done = false;
+        const listener = (notification) => {
+            const translated = this.translateNotification(notification);
+            for (const event of translated) {
+                events.push(event);
+                resolve?.();
+            }
+            // Check for terminal notifications
+            if (notification.method === "turn/completed") {
+                done = true;
+                resolve?.();
+            }
+        };
+        this.notificationListeners.push(listener);
+        try {
+            // Start the turn
+            await this.request("turn/start", {
+                threadId: this.threadId,
+                input: [{ type: "text", text: prompt }],
+                ...(options?.model && { model: options.model }),
+            });
+            // Yield events as they come in
+            while (!done) {
+                if (events.length === 0) {
+                    await new Promise((r) => {
+                        resolve = r;
+                    });
+                }
+                while (events.length > 0) {
+                    yield events.shift();
+                }
+            }
+            // Drain remaining
+            while (events.length > 0) {
+                yield events.shift();
+            }
+        }
+        finally {
+            const idx = this.notificationListeners.indexOf(listener);
+            if (idx !== -1)
+                this.notificationListeners.splice(idx, 1);
+        }
+    }
+    /** Interrupt the current turn. */
+    async interrupt() {
+        if (!this.threadId || !this.currentTurnId)
+            return;
+        try {
+            await this.request("turn/interrupt", {
+                threadId: this.threadId,
+                turnId: this.currentTurnId,
+            });
+        }
+        catch {
+            // May fail if no turn in progress
+        }
+    }
+    /** Stop the app server process. */
+    close() {
+        this.isClosing = true;
+        if (this.proc) {
+            try {
+                this.stdin?.end();
+            }
+            catch {
+                // Already closed
+            }
+            this.proc.kill();
+            this.proc = null;
+            this.stdin = null;
+            this.stdout = null;
+            this.stderr = null;
+        }
+        this.initialized = false;
+        this.threadId = null;
+        this.currentTurnId = null;
+    }
+    // ── Private ──────────────────────────────────────────────────────────────
+    async request(method, params) {
+        if (!this.stdin)
+            throw new Error("App server not started");
+        const id = this.nextId++;
+        const request = {
+            id,
+            method,
+            ...(params !== undefined && { params }),
+        };
+        if (process.env.DEBUG) {
+            console.error(`[sdk] → ${method}`, params ? JSON.stringify(params) : "");
+        }
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(id, { resolve, reject });
+            this.stdin.write(JSON.stringify(request) + "\n");
+        });
+    }
+    notify(method, params) {
+        if (!this.stdin)
+            throw new Error("App server not started");
+        const notification = {
+            method,
+            ...(params !== undefined && { params }),
+        };
+        this.stdin.write(JSON.stringify(notification) + "\n");
+    }
+    async readStdout() {
+        if (!this.stdout)
+            return;
+        const reader = this.stdout.getReader();
+        const decoder = new TextDecoder();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                this.buffer += decoder.decode(value, { stream: true });
+                let newlineIdx;
+                while ((newlineIdx = this.buffer.indexOf("\n")) !== -1) {
+                    const line = this.buffer.slice(0, newlineIdx);
+                    this.buffer = this.buffer.slice(newlineIdx + 1);
+                    if (line.trim()) {
+                        this.handleMessage(line);
+                    }
+                }
+            }
+        }
+        catch {
+            // Process exited
+        }
+    }
+    async readStderr() {
+        if (!this.stderr)
+            return;
+        const reader = this.stderr.getReader();
+        const decoder = new TextDecoder();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                this.stderrBuffer += decoder.decode(value, { stream: true });
+                let newlineIdx;
+                while ((newlineIdx = this.stderrBuffer.indexOf("\n")) !== -1) {
+                    const line = this.stderrBuffer.slice(0, newlineIdx);
+                    this.stderrBuffer = this.stderrBuffer.slice(newlineIdx + 1);
+                    this.pushStderrLine(line);
+                }
+            }
+        }
+        catch {
+            // Process exited
+        }
+        if (this.stderrBuffer.trim()) {
+            this.pushStderrLine(this.stderrBuffer);
+            this.stderrBuffer = "";
+        }
+    }
+    pushStderrLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        this.stderrHistory.push(trimmed);
+        if (this.stderrHistory.length > 60) {
+            this.stderrHistory.shift();
+        }
+        if (process.env.DEBUG) {
+            console.error(`[sdk][${this.command} stderr] ${trimmed}`);
+        }
+    }
+    stderrTail(maxLines = 8) {
+        return this.stderrHistory.slice(-maxLines).join("\n");
+    }
+    async watchProcessExit(proc) {
+        const exitCode = await proc.exited;
+        if (this.proc !== proc || this.isClosing)
+            return;
+        const tail = this.stderrTail();
+        const message = tail
+            ? `App server exited with code ${exitCode}\nRecent stderr:\n${tail}`
+            : `App server exited with code ${exitCode}`;
+        const error = new Error(message);
+        for (const [, pending] of this.pendingRequests) {
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+    handleMessage(line) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        // Response (has id)
+        if ("id" in msg && msg.id != null) {
+            const response = msg;
+            const pending = this.pendingRequests.get(response.id);
+            if (pending) {
+                this.pendingRequests.delete(response.id);
+                if (response.error) {
+                    pending.reject(new Error(response.error.message));
+                }
+                else {
+                    pending.resolve(response.result);
+                }
+            }
+            return;
+        }
+        // Notification (no id)
+        const notification = msg;
+        for (const listener of this.notificationListeners) {
+            listener(notification);
+        }
+    }
+    /** Translate app-server JSON-RPC notifications to AgentEvents. */
+    translateNotification(notification) {
+        const events = [];
+        const params = (notification.params ?? {});
+        switch (notification.method) {
+            case "item/agentMessage/delta": {
+                events.push({ type: "text", delta: params.delta });
+                break;
+            }
+            case "item/reasoning/textDelta": {
+                events.push({ type: "reasoning", delta: params.delta });
+                break;
+            }
+            case "item/started": {
+                const item = params.item;
+                if (!item)
+                    break;
+                const itemType = item.type;
+                const itemId = item.id;
+                if (itemType === "commandExecution") {
+                    events.push({
+                        type: "tool_start",
+                        id: itemId,
+                        name: "Bash",
+                        input: { command: item.command, cwd: item.cwd },
+                    });
+                }
+                else if (itemType === "fileChange") {
+                    const changes = item.changes;
+                    const firstChange = changes?.[0];
+                    const kindType = firstChange?.kind?.type;
+                    const toolName = kindType === "add" ? "Write" : "Edit";
+                    events.push({
+                        type: "tool_start",
+                        id: itemId,
+                        name: toolName,
+                        input: { file_path: firstChange?.path },
+                    });
+                }
+                else if (itemType === "mcpToolCall") {
+                    events.push({
+                        type: "tool_start",
+                        id: itemId,
+                        name: String(item.tool ?? "tool"),
+                        input: item.arguments,
+                    });
+                }
+                break;
+            }
+            case "item/completed": {
+                const item = params.item;
+                if (!item)
+                    break;
+                const itemId = item.id;
+                const itemType = item.type;
+                if (itemType === "commandExecution") {
+                    const exitCode = item.exitCode;
+                    events.push({
+                        type: "tool_end",
+                        id: itemId,
+                        result: item.aggregatedOutput,
+                        isError: (exitCode ?? 0) !== 0,
+                    });
+                }
+                else if (itemType === "fileChange") {
+                    events.push({
+                        type: "tool_end",
+                        id: itemId,
+                        result: undefined,
+                        isError: false,
+                    });
+                }
+                else if (itemType === "mcpToolCall") {
+                    events.push({
+                        type: "tool_end",
+                        id: itemId,
+                        result: item.result,
+                        isError: false,
+                    });
+                }
+                break;
+            }
+            case "turn/started": {
+                const turn = params.turn;
+                if (turn) {
+                    this.currentTurnId = turn.id;
+                }
+                break;
+            }
+            case "turn/completed": {
+                const turn = params.turn;
+                if (turn) {
+                    const status = turn.status;
+                    if (status === "failed") {
+                        const error = turn.error;
+                        events.push({
+                            type: "error",
+                            message: error?.message ?? "Unknown error",
+                        });
+                    }
+                    else {
+                        events.push({ type: "done" });
+                    }
+                }
+                else {
+                    events.push({ type: "done" });
+                }
+                this.currentTurnId = null;
+                break;
+            }
+            case "error": {
+                // Separate error notification — already handled via turn/completed
+                break;
+            }
+            // Ignored delta notifications that we don't translate to AgentEvent
+            case "item/commandExecution/outputDelta":
+            case "item/fileChange/outputDelta":
+                break;
+        }
+        return events;
+    }
+}

package/dist/create-client.d.ts

@@ -0,0 +1,7 @@
+import { AppServerClient, type AppServerClientOptions } from "./app-server-client";
+import { type ProviderConfig } from "./providers";
+export type CreateClientOptions = ({
+    provider: string;
+} & ProviderConfig) | AppServerClientOptions;
+export declare function createClient(options: CreateClientOptions): AppServerClient;
+//# sourceMappingURL=create-client.d.ts.map

package/dist/create-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-client.d.ts","sourceRoot":"","sources":["../src/create-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACnF,OAAO,EAAe,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAE/D,MAAM,MAAM,mBAAmB,GAAG,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,cAAc,CAAC,GAAG,sBAAsB,CAAC;AAEnG,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,eAAe,CAO1E"}

package/dist/create-client.js

@@ -0,0 +1,10 @@
+import { AppServerClient } from "./app-server-client";
+import { getProvider } from "./providers";
+export function createClient(options) {
+    if ("provider" in options) {
+        const { provider, ...config } = options;
+        const resolved = getProvider(provider).resolve(config);
+        return new AppServerClient(resolved);
+    }
+    return new AppServerClient(options);
+}

package/dist/gateway-client.d.ts

@@ -0,0 +1,76 @@
+export type GatewayRoutingMode = "main" | "per-peer" | "per-channel-peer" | "per-account-channel-peer";
+export type GatewayChatType = "direct" | "group" | "channel";
+export interface GatewayHealth {
+    ok: boolean;
+    provider: string;
+    defaultRoutingMode: GatewayRoutingMode;
+}
+export interface GatewayThreadRecord {
+    threadId: string;
+    routingMode: GatewayRoutingMode;
+    provider: string;
+    mcpProfileIds?: string[];
+    channel: string;
+    userId: string;
+    chatType: GatewayChatType;
+    peerId: string;
+    accountId?: string;
+    identityId?: string;
+    channelThreadId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface GatewayCreateThreadRequest {
+    channel: string;
+    userId: string;
+    text: string;
+    mcpProfileIds?: string[];
+    provider?: string;
+    chatType?: GatewayChatType;
+    peerId?: string;
+    accountId?: string;
+    identityId?: string;
+    channelThreadId?: string;
+    routingMode?: GatewayRoutingMode;
+    idempotencyKey?: string;
+}
+export interface GatewaySendThreadRequest {
+    text: string;
+    idempotencyKey?: string;
+}
+export interface GatewayReply {
+    threadId: string;
+    routingMode: GatewayRoutingMode;
+    provider: string;
+    reply: string;
+    durationMs?: number;
+    idempotencyKey?: string;
+    cached?: boolean;
+}
+export interface GatewayClientOptions {
+    baseUrl: string;
+    headers?: ConstructorParameters<typeof Headers>[0];
+    fetch?: typeof fetch;
+}
+export declare class GatewayHttpError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(status: number, body: unknown);
+}
+export declare class GatewayClient {
+    private readonly baseUrl;
+    private readonly defaultHeaders;
+    private readonly fetchImpl;
+    constructor(options: GatewayClientOptions);
+    health(): Promise<GatewayHealth>;
+    listThreads(): Promise<GatewayThreadRecord[]>;
+    getThread(threadId: string): Promise<GatewayThreadRecord | undefined>;
+    createThread(payload: GatewayCreateThreadRequest, idempotencyKey?: string): Promise<GatewayReply>;
+    sendThreadMessage(threadId: string, payload: GatewaySendThreadRequest | string, idempotencyKey?: string): Promise<GatewayReply>;
+    interruptThread(threadId: string): Promise<boolean>;
+    private unwrapData;
+    private requestJson;
+    private parseJsonOrThrow;
+    private request;
+}
+//# sourceMappingURL=gateway-client.d.ts.map

package/dist/gateway-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-client.d.ts","sourceRoot":"","sources":["../src/gateway-client.ts"],"names":[],"mappings":"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"}

package/dist/gateway-client.js

@@ -0,0 +1,97 @@
+export class GatewayHttpError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        const errorMessage = body && typeof body === "object" && "error" in body && typeof body.error === "string"
+            ? body.error
+            : `Gateway request failed with status ${status}`;
+        super(errorMessage);
+        this.name = "GatewayHttpError";
+        this.status = status;
+        this.body = body;
+    }
+}
+export class GatewayClient {
+    baseUrl;
+    defaultHeaders;
+    fetchImpl;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.trim().replace(/\/+$/, "");
+        if (!this.baseUrl) {
+            throw new Error("GatewayClient requires a non-empty baseUrl.");
+        }
+        this.defaultHeaders = new Headers(options.headers);
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async health() {
+        return this.requestJson("GET", "/v1/health");
+    }
+    async listThreads() {
+        const result = await this.requestJson("GET", "/v1/threads");
+        return result.data;
+    }
+    async getThread(threadId) {
+        const response = await this.request("GET", `/v1/threads/${encodeURIComponent(threadId)}`);
+        if (response.status === 404) {
+            return undefined;
+        }
+        return this.unwrapData(response);
+    }
+    async createThread(payload, idempotencyKey) {
+        return this.requestJson("POST", "/v1/threads", payload, idempotencyKey);
+    }
+    async sendThreadMessage(threadId, payload, idempotencyKey) {
+        const body = typeof payload === "string" ? { text: payload } : payload;
+        return this.requestJson("POST", `/v1/threads/${encodeURIComponent(threadId)}`, body, idempotencyKey);
+    }
+    async interruptThread(threadId) {
+        const response = await this.request("POST", `/v1/threads/${encodeURIComponent(threadId)}/interrupt`);
+        if (response.status === 409) {
+            return false;
+        }
+        const result = await this.parseJsonOrThrow(response);
+        return result.interrupted;
+    }
+    async unwrapData(response) {
+        const parsed = await this.parseJsonOrThrow(response);
+        if (!parsed || typeof parsed !== "object" || !("data" in parsed)) {
+            throw new Error("Gateway response is missing data.");
+        }
+        return parsed.data;
+    }
+    async requestJson(method, path, body, idempotencyKey) {
+        const response = await this.request(method, path, body, idempotencyKey);
+        return this.parseJsonOrThrow(response);
+    }
+    async parseJsonOrThrow(response) {
+        const text = await response.text();
+        let parsed;
+        if (text.length > 0) {
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch {
+                parsed = undefined;
+            }
+        }
+        if (!response.ok) {
+            throw new GatewayHttpError(response.status, parsed);
+        }
+        return parsed;
+    }
+    request(method, path, body, idempotencyKey) {
+        const headers = new Headers(this.defaultHeaders);
+        if (idempotencyKey?.trim()) {
+            headers.set("idempotency-key", idempotencyKey.trim());
+        }
+        const requestInit = {
+            method,
+            headers,
+        };
+        if (body !== undefined) {
+            headers.set("content-type", "application/json");
+            requestInit.body = JSON.stringify(body);
+        }
+        return this.fetchImpl(`${this.baseUrl}${path}`, requestInit);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { AppServerClient, type AppServerClientOptions, type CreateThreadOptions, type PromptOptions, type ResumeThreadOptions, } from "./app-server-client";
+export type { AgentEvent } from "./types";
+export { createClient, type CreateClientOptions } from "./create-client";
+export { registerProvider, type Provider, type ProviderConfig } from "./providers";
+export { GatewayClient, GatewayHttpError, type GatewayChatType, type GatewayClientOptions, type GatewayCreateThreadRequest, type GatewayHealth, type GatewayReply, type GatewayRoutingMode, type GatewaySendThreadRequest, type GatewayThreadRecord, } from "./gateway-client";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,sBAAsB,EAC3B,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,mBAAmB,GACzB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AACnF,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,0BAA0B,EAC/B,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,GACzB,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export { AppServerClient, } from "./app-server-client";
+export { createClient } from "./create-client";
+export { registerProvider } from "./providers";
+export { GatewayClient, GatewayHttpError, } from "./gateway-client";

package/dist/providers.d.ts

@@ -0,0 +1,11 @@
+import type { AppServerClientOptions } from "./app-server-client";
+export interface ProviderConfig {
+    cwd: string;
+    env?: Record<string, string>;
+}
+export interface Provider {
+    resolve(config: ProviderConfig): AppServerClientOptions;
+}
+export declare function registerProvider(name: string, provider: Provider): void;
+export declare function getProvider(name: string): Provider;
+//# sourceMappingURL=providers.d.ts.map

package/dist/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAElE,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,CAAC,MAAM,EAAE,cAAc,GAAG,sBAAsB,CAAC;CACzD;AA+CD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAEvE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAMlD"}

package/dist/providers.js

@@ -0,0 +1,64 @@
+import { join, dirname } from "path";
+import { createRequire } from "module";
+const claudeProvider = {
+    resolve(config) {
+        const pkgPath = resolvePackagePath("@flint-dev/claude-app-server/package.json");
+        const entry = join(dirname(pkgPath), "src/index.ts");
+        return {
+            command: "bun",
+            args: ["run", entry],
+            cwd: config.cwd,
+            env: config.env,
+        };
+    },
+};
+const codexProvider = {
+    resolve(config) {
+        return {
+            command: "codex",
+            args: ["app-server"],
+            cwd: config.cwd,
+            env: config.env,
+        };
+    },
+};
+const piProvider = {
+    resolve(config) {
+        const pkgPath = resolvePackagePath("@flint-dev/pi-app-server/package.json");
+        const entry = join(dirname(pkgPath), "src/index.ts");
+        return {
+            command: "bun",
+            args: ["run", entry],
+            cwd: config.cwd,
+            env: config.env,
+        };
+    },
+};
+const builtins = new Map([
+    ["claude", claudeProvider],
+    ["codex", codexProvider],
+    ["pi", piProvider],
+]);
+const custom = new Map();
+export function registerProvider(name, provider) {
+    custom.set(name, provider);
+}
+export function getProvider(name) {
+    const provider = custom.get(name) ?? builtins.get(name);
+    if (!provider) {
+        throw new Error(`Unknown provider: "${name}". Register it with registerProvider().`);
+    }
+    return provider;
+}
+function resolvePackagePath(specifier) {
+    const consumerRequire = createRequire(join(process.cwd(), "__placeholder__.js"));
+    try {
+        // First try consumer resolution (published package use-case).
+        return consumerRequire.resolve(specifier);
+    }
+    catch {
+        // Fall back to SDK-local resolution (workspace/dev use-case).
+        const sdkRequire = createRequire(import.meta.url);
+        return sdkRequire.resolve(specifier);
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+export type AgentEvent = {
+    type: "init";
+    sessionId: string;
+} | {
+    type: "text";
+    delta: string;
+} | {
+    type: "reasoning";
+    delta: string;
+} | {
+    type: "tool_start";
+    id: string;
+    name: string;
+    input?: unknown;
+    parentId?: string | null;
+} | {
+    type: "tool_end";
+    id: string;
+    result?: unknown;
+    isError: boolean;
+    parentId?: string | null;
+} | {
+    type: "done";
+    usage?: {
+        input: number;
+        output: number;
+    };
+} | {
+    type: "error";
+    message: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC3F;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GAC9F;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@flint-dev/sdk",
+  "version": "0.2.0",
+  "description": "TypeScript client SDK for Flint app servers",
+  "license": "MIT",
+  "author": "Aaron Escalona",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepack": "bun run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@flint-dev/claude-app-server": "^0.2.0",
+    "@flint-dev/pi-app-server": "^0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@flint-dev/claude-app-server": {
+      "optional": true
+    },
+    "@flint-dev/pi-app-server": {
+      "optional": true
+    }
+  }
+}