@flue/sdk 0.3.11 → 0.4.0

package/README.md

@@ -42,15 +42,15 @@ export default async function ({ init, payload }: FlueContext) {
   const session = await agent.session();
 
   // prompt() sends a message in the session, triggering action.
-  const result = await session.prompt(`Translate this to ${payload.language}: "${payload.text}"`, {
-    // Pass a result schema to get typed, schema-validated data back from your agent.
-    result: v.object({
+  const { data } = await session.prompt(`Translate this to ${payload.language}: "${payload.text}"`, {
+    // Pass a `schema` to get typed, schema-validated data back from your agent.
+    schema: v.object({
       translation: v.string(),
       confidence: v.picklist(['low', 'medium', 'high']),
     }),
   });
 
-  return result;
+  return data;
 }
 ```
 
@@ -91,28 +91,21 @@ export default async function ({ init, payload, env }: FlueContext) {
 
 ### Issue Triage (CI)
 
-A triage agent that runs in CI whenever an issue is opened on GitHub. The `"local"` sandbox mounts the host filesystem and lets you connect privileged CLIs (`gh`, `npm`, `git`) to the agent without leaking secrets.
+A triage agent that runs in CI whenever an issue is opened on GitHub. The `"local"` sandbox gives the agent direct access to the host filesystem and shell — perfect for CI runners, where `gh`, `git`, and `npm` are already on `$PATH` and the runner itself is your isolation boundary.
 
 ```ts
 // .flue/agents/triage.ts
 import { type FlueContext } from '@flue/sdk/client';
-import { defineCommand } from '@flue/sdk/node';
 import * as v from 'valibot';
 
 // Because we are running this in CI, we don't need to expose this as an HTTP endpoint.
 // The CLI can run any agent from the command line, `flue run triage ...`
 export const triggers = {};
 
-// Connect privileged CLIs to your agent without leaking sensitive keys and secrets.
-// Secrets are hooked up inside the command definition here, so your agent never sees them.
-// Commands are controlled per-prompt, so you can be as granular with access as you need.
-const npm = defineCommand('npm');
-const gh = defineCommand('gh', { env: { GH_TOKEN: process.env.GH_TOKEN } });
-
 export default async function ({ init, payload }: FlueContext) {
-  // 'local' mounts the host filesystem at /workspace — ideal for CI
-  // where the repo is already checked out. Skills and AGENTS.md are
-  // discovered automatically from the workspace directory.
+  // 'local' gives the agent direct access to the host filesystem and
+  // shell. The agent's bash tool can run `gh`, `git`, `npm` directly.
+  // Skills and AGENTS.md are discovered from process.cwd().
   //
   // `model` sets the default model for every prompt/skill call in this
   // agent. Override per-call with `{ model: '...' }` on prompt()/skill().
@@ -126,14 +119,12 @@ export default async function ({ init, payload }: FlueContext) {
   // or by a relative path under `.agents/skills/` — e.g.
   // `session.skill('triage/reproduce.md', ...)`. Path references are handy for
   // skill packs that group multiple stages under one directory.
-  const result = await session.skill('triage', {
+  const { data } = await session.skill('triage', {
     // Pass arguments to any prompt or skill.
     args: { issueNumber: payload.issueNumber },
-    // Grant access to `gh` and `npm` for the life of this skill.
-    commands: [gh, npm],
-    // Result schemas are great for being able to act/orchestrate
-    // based on the result of your prompt or skill call.
-    result: v.object({
+    // Schemas are great for being able to act/orchestrate based on
+    // the structured `data` returned from your prompt or skill call.
+    schema: v.object({
       severity: v.picklist(['low', 'medium', 'high', 'critical']),
       reproducible: v.boolean(),
       summary: v.string(),
@@ -141,7 +132,7 @@ export default async function ({ init, payload }: FlueContext) {
     }),
   });
 
-  return result;
+  return data;
 }
 ```
 
@@ -171,7 +162,7 @@ export default async function ({ init, payload, env }: FlueContext) {
   const client = new Daytona({ apiKey: env.DAYTONA_API_KEY });
   const sandbox = await client.create();
   const setupAgent = await init({
-    sandbox: daytona(sandbox, { cleanup: true }),
+    sandbox: daytona(sandbox),
     model: 'openai/gpt-5.5',
   });
   const setup = await setupAgent.session();

package/dist/abort-Bg3qsAkU.mjs

@@ -0,0 +1,43 @@
+//#region src/abort.ts
+/** Build a standard `AbortError` (`DOMException`) carrying the signal's reason as `cause`. */
+function abortErrorFor(signal) {
+	const reason = signal.reason;
+	const message = reason instanceof Error && reason.message ? reason.message : typeof reason === "string" && reason ? reason : "The operation was aborted.";
+	const error = new DOMException(message, "AbortError");
+	try {
+		Object.defineProperty(error, "cause", {
+			value: reason,
+			configurable: true
+		});
+	} catch {}
+	return error;
+}
+/**
+* Wrap an async `run` function in a `CallHandle`. The handle's internal
+* signal fires when `externalSignal` aborts or when `handle.abort()` is
+* called.
+*/
+function createCallHandle(externalSignal, run) {
+	const controller = new AbortController();
+	let externalListener;
+	if (externalSignal) if (externalSignal.aborted) controller.abort(externalSignal.reason);
+	else {
+		externalListener = () => controller.abort(externalSignal.reason);
+		externalSignal.addEventListener("abort", externalListener, { once: true });
+	}
+	const promise = run(controller.signal).finally(() => {
+		if (externalListener && externalSignal) externalSignal.removeEventListener("abort", externalListener);
+	});
+	return {
+		signal: controller.signal,
+		abort(reason) {
+			controller.abort(reason);
+		},
+		then(onFulfilled, onRejected) {
+			return promise.then(onFulfilled, onRejected);
+		}
+	};
+}
+
+//#endregion
+export { createCallHandle as n, abortErrorFor as t };

package/dist/app.d.mts

@@ -0,0 +1,106 @@
+import { w as ProviderSettings } from "./types-BAmV4f3Q.mjs";
+import { i as flue } from "./flue-app-CG8i4wNG.mjs";
+import { t as CLOUDFLARE_AI_BINDING_API } from "./cloudflare-model-BeiZ1pLz.mjs";
+import { Api, Model, registerApiProvider as registerApiProvider$1 } from "@mariozechner/pi-ai";
+
+//#region src/runtime/providers.d.ts
+/**
+ * Minimal Workers AI binding shape. Kept structural so `@flue/sdk/app` stays
+ * importable on Node.
+ */
+interface CloudflareAIBinding {
+  run(model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>): Promise<Response | Record<string, unknown>>;
+}
+/**
+ * Provider declarations keyed by URL prefix. HTTP providers carry endpoint
+ * settings; Workers AI binding providers carry the captured binding object.
+ */
+type ProviderRegistration = HttpProviderRegistration | CloudflareAIBindingRegistration;
+interface HttpProviderRegistration {
+  api: Api;
+  /** Endpoint root, e.g. `'https://api.anthropic.com/v1'`. */
+  baseUrl: string;
+  /**
+   * Optional API key. Propagated to pi-ai via the harness's per-call
+   * `getApiKey(provider)` callback. Falls back to whatever pi-ai's normal
+   * env-var lookup produces if unset.
+   */
+  apiKey?: string;
+  /** Optional default headers for every outgoing request. */
+  headers?: Record<string, string>;
+  /**
+   * Override the pi-ai `provider` slug surfaced on AssistantMessage records
+   * and `configureProvider()` overrides. Defaults to the registry name.
+   */
+  provider?: string;
+}
+interface CloudflareAIBindingRegistration {
+  api: typeof CLOUDFLARE_AI_BINDING_API;
+  /** The captured `env.AI` reference. Read at registration time. */
+  binding: CloudflareAIBinding;
+  /**
+   * Override the pi-ai `provider` slug. Defaults to `'workers-ai'`,
+   * matching pi-ai's catalog convention for Cloudflare-Workers-AI models.
+   */
+  provider?: string;
+}
+/**
+ * Register a Flue-level model provider keyed by URL prefix.
+ *
+ * Last-write-wins. On Cloudflare, the generated entry reserves the
+ * `cloudflare` prefix for the built-in Workers AI binding integration.
+ */
+declare function registerProvider(name: string, registration: ProviderRegistration): void;
+/**
+ * Re-export of pi-ai's `registerApiProvider`. Use to register a brand-new
+ * wire-protocol handler for an `api` slug pi-ai doesn't ship. Then call
+ * {@link registerProvider} to alias a URL prefix to that api.
+ *
+ * ```ts
+ * registerApiProvider({ api: 'my-novel-api', stream, streamSimple });
+ * registerProvider('thing', { api: 'my-novel-api', baseUrl: '...', apiKey: '...' });
+ * ```
+ *
+ * pi-ai's registry is also module-scoped and last-write-wins. Calling
+ * `registerApiProvider` repeatedly with the same `api` string overwrites,
+ * so generated code can register on every isolate boot without dedupe
+ * bookkeeping.
+ */
+declare const registerApiProvider: typeof registerApiProvider$1;
+/**
+ * Provider settings accepted by {@link configureProvider}.
+ */
+type ProviderConfiguration = ProviderSettings;
+/**
+ * Patch transport-level settings on an existing provider while preserving its
+ * resolved Model metadata (cost, context window, token limits, etc.).
+ *
+ * ```ts
+ * import { configureProvider } from '@flue/sdk/app';
+ *
+ * configureProvider('anthropic', {
+ *   baseUrl: 'https://gateway.example.com/anthropic',
+ *   apiKey: process.env.GATEWAY_KEY,
+ * });
+ * ```
+ *
+ * Keyed by the resolved `Model.provider` value, not necessarily the URL
+ * prefix. Last-write-wins.
+ */
+declare function configureProvider(provider: string, settings: ProviderConfiguration): void;
+//#endregion
+//#region src/app.d.ts
+/**
+ * Shape contract for a user-authored `app.ts` default export. Any
+ * object exposing a `fetch(request, env?, ctx?)` method satisfies it,
+ * including a `new Hono()` instance.
+ *
+ * The `env` and `ctx` parameters are passed through on the Cloudflare
+ * target (env = bindings, ctx = ExecutionContext); on Node they are
+ * undefined.
+ */
+interface Fetchable {
+  fetch(request: Request, env?: unknown, ctx?: unknown): Response | Promise<Response>;
+}
+//#endregion
+export { type CloudflareAIBinding, type CloudflareAIBindingRegistration, Fetchable, type HttpProviderRegistration, type ProviderConfiguration, type ProviderRegistration, configureProvider, flue, registerApiProvider, registerProvider };

package/dist/app.mjs

@@ -0,0 +1,4 @@
+import { r as flue } from "./flue-app-DeTOZjPs.mjs";
+import { a as registerApiProvider, o as registerProvider, t as configureProvider } from "./providers-DeFRIwp0.mjs";
+
+export { configureProvider, flue, registerApiProvider, registerProvider };

package/dist/client.d.mts

@@ -1,5 +1,5 @@
-import { A as ShellResult, D as SessionOptions, E as SessionEnv, F as ToolParameters, M as SkillOptions, N as TaskOptions, O as SessionStore, P as ToolDef, S as ProvidersConfig, T as SessionData, _ as FlueSessions, a as BashLike, b as PromptResponse, d as FileStat, f as FlueAgent, g as FlueSession, h as FlueEventCallback, i as BashFactory, k as ShellOptions, l as Command, m as FlueEvent, p as FlueContext, r as AgentInit, t as AgentConfig, v as ModelConfig, w as SandboxFactory, x as ProviderSettings, y as PromptOptions } from "./types-DGpyKMFm.mjs";
-import { i as connectMcpServer, n as McpServerOptions, r as McpTransport, t as McpServerConnection } from "./mcp-CcRxAwXW.mjs";
+import { A as SessionStore, C as PromptUsage, D as SessionData, E as SandboxFactory, F as TaskOptions, I as ThinkingLevel, L as ToolDef, M as ShellResult, O as SessionEnv, P as SkillOptions, R as ToolParameters, S as PromptResultResponse, _ as FlueSessions, a as BashLike, b as PromptOptions, d as FlueAgent, f as FlueContext, g as FlueSession, h as FlueFs, i as BashFactory, j as ShellOptions, k as SessionOptions, m as FlueEventCallback, p as FlueEvent, r as AgentInit, t as AgentConfig, u as FileStat, v as ModelConfig, w as ProviderSettings, x as PromptResponse, y as PromptModel } from "./types-BAmV4f3Q.mjs";
+import { i as connectMcpServer, n as McpServerOptions, r as McpTransport, t as McpServerConnection } from "./mcp-C3UBXVkR.mjs";
 import { Type } from "@mariozechner/pi-ai";
 
 //#region src/client.d.ts
@@ -16,6 +16,12 @@ interface FlueContextConfig {
    * Returns SessionEnv to use, or null to fall through to default logic.
    */
   resolveSandbox?: (sandbox: unknown) => Promise<SessionEnv> | null;
+  /**
+   * The current HTTP request, if any. Surfaced to handlers as `ctx.req`.
+   * Build plugins pass the standard Fetch `Request` through; non-HTTP entry
+   * points (e.g. future cron triggers) leave it undefined.
+   */
+  req?: Request;
 }
 /** Extends FlueContext with server-only methods. Agent handlers only see FlueContext. */
 interface FlueContextInternal extends FlueContext {
@@ -23,4 +29,4 @@ interface FlueContextInternal extends FlueContext {
 }
 declare function createFlueContext(config: FlueContextConfig): FlueContextInternal;
 //#endregion
-export { type AgentInit, type BashFactory, type BashLike, type Command, type FileStat, type FlueAgent, type FlueContext, FlueContextConfig, FlueContextInternal, type FlueEvent, type FlueEventCallback, type FlueSession, type FlueSessions, type McpServerConnection, type McpServerOptions, type McpTransport, type ModelConfig, type PromptOptions, type PromptResponse, type ProviderSettings, type ProvidersConfig, type SandboxFactory, type SessionData, type SessionEnv, type SessionOptions, type SessionStore, type ShellOptions, type ShellResult, type SkillOptions, type TaskOptions, type ToolDef, type ToolParameters, Type, connectMcpServer, createFlueContext };
+export { type AgentInit, type BashFactory, type BashLike, type FileStat, type FlueAgent, type FlueContext, FlueContextConfig, FlueContextInternal, type FlueEvent, type FlueEventCallback, type FlueFs, type FlueSession, type FlueSessions, type McpServerConnection, type McpServerOptions, type McpTransport, type ModelConfig, type PromptModel, type PromptOptions, type PromptResponse, type PromptResultResponse, type PromptUsage, type ProviderSettings, type SandboxFactory, type SessionData, type SessionEnv, type SessionOptions, type SessionStore, type ShellOptions, type ShellResult, type SkillOptions, type TaskOptions, type ThinkingLevel, type ToolDef, type ToolParameters, Type, connectMcpServer, createFlueContext };

package/dist/client.mjs

@@ -1,7 +1,8 @@
-import { r as discoverSessionContext } from "./agent-Cahthgu3.mjs";
-import { a as assertRoleExists } from "./session-DlwIt7wq.mjs";
+import { u as discoverSessionContext } from "./result-K1IRhWKM.mjs";
+import "./providers-DeFRIwp0.mjs";
+import { a as assertRoleExists } from "./session-CO_uGVOk.mjs";
 import { bashFactoryToSessionEnv, createCwdSessionEnv } from "./sandbox.mjs";
-import { n as AgentClient, t as connectMcpServer } from "./mcp-DmDTeVXW.mjs";
+import { n as AgentClient, t as connectMcpServer } from "./mcp-2SW_tpox.mjs";
 import { Type } from "@mariozechner/pi-ai";
 
 //#region src/client.ts
@@ -18,6 +19,9 @@ function createFlueContext(config) {
 		get env() {
 			return config.env;
 		},
+		get req() {
+			return config.req;
+		},
 		async init(options) {
 			if (!options || !("model" in options)) throw new Error("[flue] init() requires a model. Pass { model: \"provider/model-id\" } or { model: false }.");
 			if (options.model !== false && typeof options.model !== "string") throw new Error("[flue] init({ model }) must be a model string or false.");
@@ -31,16 +35,15 @@ function createFlueContext(config) {
 				const env = options.cwd ? createCwdSessionEnv(baseEnv, options.cwd) : baseEnv;
 				const store = options.persist ?? config.defaultStore;
 				const localContext = await discoverSessionContext(env);
-				const providers = mergeProvidersConfig(config.agentConfig.providers, options.providers);
-				const agentModel = config.agentConfig.resolveModel(options.model, providers);
+				const agentModel = config.agentConfig.resolveModel(options.model);
 				return new AgentClient(id, {
 					...config.agentConfig,
 					systemPrompt: localContext.systemPrompt,
 					skills: localContext.skills,
 					model: agentModel,
 					role: options.role ?? config.agentConfig.role,
-					providers
-				}, env, store, currentEventCallback, options.commands, options.tools);
+					thinkingLevel: options.thinkingLevel ?? config.agentConfig.thinkingLevel
+				}, env, store, currentEventCallback, options.tools);
 			} catch (error) {
 				initializedAgentIds.delete(id);
 				throw error;
@@ -77,23 +80,6 @@ async function resolveSessionEnv(id, sandbox, config, cwd) {
 	});
 	throw new Error("[flue] Invalid sandbox option passed to init().");
 }
-function mergeProvidersConfig(base, settings) {
-	if (!base) return settings;
-	if (!settings) return base;
-	const merged = { ...base };
-	for (const [provider, config] of Object.entries(settings)) {
-		const previous = merged[provider];
-		merged[provider] = {
-			...previous,
-			...config,
-			headers: previous?.headers || config.headers ? {
-				...previous?.headers ?? {},
-				...config.headers ?? {}
-			} : void 0
-		};
-	}
-	return merged;
-}
 
 //#endregion
 export { Type, connectMcpServer, createFlueContext };

package/dist/cloudflare/index.d.mts

@@ -1,5 +1,6 @@
-import { E as SessionEnv, O as SessionStore, l as Command } from "../types-DGpyKMFm.mjs";
-import { t as CommandExecutor } from "../command-helpers-eVG1-Iru.mjs";
+import { A as SessionStore, O as SessionEnv } from "../types-BAmV4f3Q.mjs";
+import { n as CloudflareAIBindingApi } from "../cloudflare-model-BeiZ1pLz.mjs";
+import { ApiProvider, StreamOptions } from "@mariozechner/pi-ai";
 
 //#region src/cloudflare/virtual-sandbox.d.ts
 interface VirtualSandboxOptions {
@@ -9,9 +10,6 @@ interface VirtualSandboxOptions {
 declare function getVirtualSandbox(): Promise<any>;
 declare function getVirtualSandbox(bucket: unknown, options?: VirtualSandboxOptions): Promise<any>;
 //#endregion
-//#region src/cloudflare/define-command.d.ts
-declare function defineCommand(name: string, execute: CommandExecutor): Command;
-//#endregion
 //#region src/cloudflare/cf-sandbox.d.ts
 declare function cfSandboxToSessionEnv(sandbox: any, cwd?: string): Promise<SessionEnv>;
 //#endregion
@@ -32,4 +30,10 @@ interface CloudflareContext {
 declare function runWithCloudflareContext<T>(ctx: CloudflareContext, fn: () => T): T;
 declare function getCloudflareContext(): CloudflareContext;
 //#endregion
-export { type CloudflareContext, type VirtualSandboxOptions, cfSandboxToSessionEnv, defineCommand, getCloudflareContext, getVirtualSandbox, runWithCloudflareContext, store };
+//#region src/cloudflare/workers-ai-provider.d.ts
+/**
+ * Return the pi-ai `ApiProvider` definition for the Cloudflare AI binding.
+ */
+declare function getCloudflareAIBindingApiProvider(): ApiProvider<CloudflareAIBindingApi, StreamOptions>;
+//#endregion
+export { type CloudflareContext, type VirtualSandboxOptions, cfSandboxToSessionEnv, getCloudflareAIBindingApiProvider, getCloudflareContext, getVirtualSandbox, runWithCloudflareContext, store };