@flue/sdk 0.3.11 → 0.4.1

package/dist/node/index.mjs

@@ -1,75 +1,105 @@
-import { t as normalizeExecutor } from "../command-helpers-hTZKWK13.mjs";
-import { execFile } from "node:child_process";
+import { t as abortErrorFor } from "../abort-Bg3qsAkU.mjs";
+import * as path from "node:path";
+import { exec } from "node:child_process";
 import { promisify } from "node:util";
+import * as fs from "node:fs/promises";
 
-//#region src/node/define-command.ts
+//#region src/node/local-env.ts
 /**
-* Node-specific `defineCommand`. Supports three forms:
+* Pure-Node `SessionEnv` backed by the host filesystem and `child_process`.
 *
-* ```ts
-* defineCommand('agent-browser');
-* defineCommand('gh', { env: { GH_TOKEN: process.env.GH_TOKEN } });
-* defineCommand('gh', async (args) => ({ stdout: '...' }));
-* ```
+* Powers `init({ sandbox: 'local' })` on the Node target. No sandboxing,
+* no virtual filesystem, no just-bash — `exec` shells out via the user's
+* default shell, file methods call `node:fs/promises` directly.
 *
-* Forms A and B shell out via `child_process.execFile`. Form C lets the user
-* implement the command however they like. All three forms benefit from
-* return-shape normalization and throw-catching — no `try`/`catch` or
-* `return { stdout, stderr, exitCode: 0 }` boilerplate required.
+* Use this when you're running flue inside an external sandbox (Daytona,
+* E2B, a container, a CI runner, etc.) and want flue itself to operate on
+* the host filesystem without an additional layer of isolation.
 */
-const execFileAsync = promisify(execFile);
-/**
-* Essential, non-sensitive environment variables automatically forwarded to
-* pass-through commands (forms A and B). Users can override any of these —
-* or add their own (e.g. `GH_TOKEN`) — via `options.env`. Anything not listed
-* here (API keys, tokens, secrets, etc.) stays on the host and is NEVER
-* exposed to the spawned process unless the caller opts in explicitly.
-*
-* If you need full control over the env, use the function form:
-* `defineCommand('gh', async (args) => { ... })`.
-*/
-const DEFAULT_ENV = {
-	PATH: process.env.PATH,
-	HOME: process.env.HOME,
-	USER: process.env.USER,
-	LOGNAME: process.env.LOGNAME,
-	HOSTNAME: process.env.HOSTNAME,
-	SHELL: process.env.SHELL,
-	LANG: process.env.LANG,
-	LC_ALL: process.env.LC_ALL,
-	LC_CTYPE: process.env.LC_CTYPE,
-	TZ: process.env.TZ,
-	TERM: process.env.TERM,
-	TMPDIR: process.env.TMPDIR,
-	TMP: process.env.TMP,
-	TEMP: process.env.TEMP
-};
-function defineCommand(name, arg) {
-	if (typeof arg === "function") return {
-		name,
-		execute: normalizeExecutor(arg)
-	};
-	const userOpts = arg ?? {};
-	const mergedOpts = {
-		maxBuffer: 50 * 1024 * 1024,
-		...userOpts,
-		env: {
-			...DEFAULT_ENV,
-			...userOpts.env ?? {}
-		}
-	};
-	const executor = async (args) => {
-		const { stdout, stderr } = await execFileAsync(name, args, mergedOpts);
-		return {
-			stdout: String(stdout ?? ""),
-			stderr: String(stderr ?? "")
-		};
-	};
+const execAsync = promisify(exec);
+function createLocalSessionEnv(options = {}) {
+	const cwd = path.resolve(options.cwd ?? process.cwd());
+	const resolvePath = (p) => path.isAbsolute(p) ? p : path.resolve(cwd, p);
 	return {
-		name,
-		execute: normalizeExecutor(executor)
+		async exec(command, opts) {
+			const signal = opts?.signal;
+			if (signal?.aborted) throw abortErrorFor(signal);
+			const timeoutSignal = typeof opts?.timeout === "number" ? AbortSignal.timeout(opts.timeout * 1e3) : void 0;
+			const mergedSignal = signal && timeoutSignal ? AbortSignal.any([signal, timeoutSignal]) : signal ?? timeoutSignal;
+			try {
+				const { stdout, stderr } = await execAsync(command, {
+					cwd: opts?.cwd ? resolvePath(opts.cwd) : cwd,
+					env: opts?.env ? {
+						...process.env,
+						...opts.env
+					} : process.env,
+					signal: mergedSignal,
+					encoding: "utf8",
+					maxBuffer: 64 * 1024 * 1024
+				});
+				if (signal?.aborted) throw abortErrorFor(signal);
+				return {
+					stdout,
+					stderr,
+					exitCode: 0
+				};
+			} catch (err) {
+				if (signal?.aborted) throw abortErrorFor(signal);
+				if (err && typeof err === "object" && "code" in err) return {
+					stdout: typeof err.stdout === "string" ? err.stdout : "",
+					stderr: typeof err.stderr === "string" ? err.stderr : String(err.message ?? ""),
+					exitCode: typeof err.code === "number" ? err.code : 1
+				};
+				throw err;
+			}
+		},
+		async readFile(p) {
+			return fs.readFile(resolvePath(p), "utf8");
+		},
+		async readFileBuffer(p) {
+			const buf = await fs.readFile(resolvePath(p));
+			return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+		},
+		async writeFile(p, content) {
+			const resolved = resolvePath(p);
+			const dir = path.dirname(resolved);
+			if (dir && dir !== resolved) await fs.mkdir(dir, { recursive: true });
+			await fs.writeFile(resolved, content);
+		},
+		async stat(p) {
+			const s = await fs.stat(resolvePath(p));
+			return {
+				isFile: s.isFile(),
+				isDirectory: s.isDirectory(),
+				isSymbolicLink: s.isSymbolicLink(),
+				size: s.size,
+				mtime: s.mtime
+			};
+		},
+		async readdir(p) {
+			return fs.readdir(resolvePath(p));
+		},
+		async exists(p) {
+			try {
+				await fs.access(resolvePath(p));
+				return true;
+			} catch {
+				return false;
+			}
+		},
+		async mkdir(p, opts) {
+			await fs.mkdir(resolvePath(p), { recursive: opts?.recursive ?? false });
+		},
+		async rm(p, opts) {
+			await fs.rm(resolvePath(p), {
+				recursive: opts?.recursive ?? false,
+				force: opts?.force ?? false
+			});
+		},
+		cwd,
+		resolvePath
 	};
 }
 
 //#endregion
-export { defineCommand };
+export { createLocalSessionEnv };

package/dist/providers-DeFRIwp0.mjs

@@ -0,0 +1,158 @@
+import { registerApiProvider } from "@mariozechner/pi-ai";
+
+//#region src/cloudflare-model.ts
+/** Pi-ai `Api` slug for the binding-backed Workers AI provider. */
+const CLOUDFLARE_AI_BINDING_API = "cloudflare-ai-binding";
+/** Provider name surfaced on AssistantMessage records and usage logs. */
+const CLOUDFLARE_AI_BINDING_PROVIDER = "workers-ai";
+
+//#endregion
+//#region src/runtime/providers.ts
+/** Runtime provider registries consumed by `resolveModel` and Session. */
+/**
+* pi-ai's open-ended `Api` type prevents direct discriminator narrowing.
+*/
+function isCloudflareBindingRegistration(def) {
+	return def.api === CLOUDFLARE_AI_BINDING_API;
+}
+/**
+* URL-prefix registry populated at module init by `app.ts` and generated
+* server entries.
+*/
+const userModels = /* @__PURE__ */ new Map();
+/**
+* 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.
+*/
+function registerProvider(name, registration) {
+	userModels.set(name, registration);
+}
+/**
+* Look up a registration apiKey by the resolved pi-ai provider slug.
+*/
+function getRegisteredApiKey(provider) {
+	for (const [name, def] of userModels) {
+		if (effectiveProviderSlug(name, def) !== provider) continue;
+		if (!isCloudflareBindingRegistration(def)) return def.apiKey;
+	}
+}
+/**
+* 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.
+*/
+const registerApiProvider$1 = registerApiProvider;
+const providerOverrides = /* @__PURE__ */ new Map();
+/**
+* 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.
+*/
+function configureProvider(provider, settings) {
+	providerOverrides.set(provider, settings);
+}
+/**
+* Internal read accessor for provider overrides.
+*/
+function getProviderConfiguration(provider) {
+	return providerOverrides.get(provider);
+}
+/** Attach a Workers AI binding to a Model literal. */
+function attachModelBinding(model, binding) {
+	return {
+		...model,
+		binding
+	};
+}
+/**
+* Read a Workers AI binding off a resolved Model, or `undefined` if no
+* usable binding is attached.
+*/
+function getModelBinding(model) {
+	const candidate = model.binding;
+	if (!candidate || typeof candidate.run !== "function") return;
+	return candidate;
+}
+/**
+* Resolve `'name/modelId'` against the URL-prefix registry.
+*/
+function resolveRegisteredModel(name, modelId) {
+	const def = userModels.get(name);
+	if (!def) return void 0;
+	return buildModelFromRegistration(name, def, modelId);
+}
+/**
+* Construct a pi-ai Model from a registered provider template. User-defined
+* providers do not have catalog metadata, so cost and context limits default
+* to zero. apiKey flows through `getApiKey`; it is not part of pi-ai's Model.
+*/
+function buildModelFromRegistration(name, def, modelId) {
+	if (isCloudflareBindingRegistration(def)) return attachModelBinding({
+		id: modelId,
+		name: modelId,
+		api: CLOUDFLARE_AI_BINDING_API,
+		provider: def.provider ?? CLOUDFLARE_AI_BINDING_PROVIDER,
+		baseUrl: "",
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 0,
+		maxTokens: 0
+	}, def.binding);
+	return {
+		id: modelId,
+		name: modelId,
+		api: def.api,
+		provider: def.provider ?? name,
+		baseUrl: def.baseUrl,
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 0,
+		maxTokens: 0,
+		headers: def.headers
+	};
+}
+/**
+* Compute the provider slug emitted on the resolved Model.
+*/
+function effectiveProviderSlug(name, def) {
+	if (isCloudflareBindingRegistration(def)) return def.provider ?? CLOUDFLARE_AI_BINDING_PROVIDER;
+	return def.provider ?? name;
+}
+
+//#endregion
+export { registerApiProvider$1 as a, CLOUDFLARE_AI_BINDING_API as c, getRegisteredApiKey as i, getModelBinding as n, registerProvider as o, getProviderConfiguration as r, resolveRegisteredModel as s, configureProvider as t };