@flue/sdk 0.3.11 → 0.4.1

package/dist/internal.mjs

@@ -1,426 +1,12 @@
-import "./agent-Cahthgu3.mjs";
-import { t as InMemorySessionStore } from "./session-DlwIt7wq.mjs";
+import "./result-K1IRhWKM.mjs";
+import { i as handleAgentRequest, n as createDefaultFlueApp, t as configureFlueRuntime } from "./flue-app-DeTOZjPs.mjs";
+import { r as getProviderConfiguration, s as resolveRegisteredModel } from "./providers-DeFRIwp0.mjs";
+import { t as InMemorySessionStore } from "./session-CFOByKnM.mjs";
 import { bashFactoryToSessionEnv } from "./sandbox.mjs";
-import "./mcp-DmDTeVXW.mjs";
+import "./mcp-DM6yv_Qc.mjs";
 import { createFlueContext } from "./client.mjs";
 import { getModel } from "@mariozechner/pi-ai";
 
-//#region src/errors.ts
-/**
-* Concrete error classes thrown by Flue.
-*
-* This file is the *vocabulary* of errors in Flue. Every error the framework
-* throws has a class here. The framework scaffolding (base class, renderers,
-* type guards, request-parsing helpers) lives in `error-utils.ts`.
-*
-* ──── Why this file exists ────────────────────────────────────────────────
-*
-* Concentrating every error in one file is deliberate. When all errors are
-* visible together, it's easy to:
-*
-*   - Keep message tone and detail level consistent across the codebase.
-*   - Notice duplicates ("oh, we already have an error for this case").
-*   - Establish norms by example — when adding a new error, look at the
-*     neighbors above and copy the pattern.
-*
-* Application code throughout the codebase should reach for one of these
-* classes rather than constructing a `FlueError` ad hoc. If no existing class
-* fits, add one here. That's the entire convention.
-*
-* ──── Two audiences: caller vs. developer ─────────────────────────────────
-*
-* The reader of an error message is one of two distinct audiences:
-*
-*   - The *caller*: an HTTP client. Possibly third-party, possibly hostile,
-*     possibly an end user who shouldn't even know we're built on Flue.
-*     Sees `message` and `details` always.
-*
-*   - The *developer*: the human running the service (`flue dev`, `flue run`,
-*     local debugging). Sees `dev` in addition, but only when the server is
-*     running in local/dev mode (gated by `FLUE_MODE=local`).
-*
-* Every error class must classify its prose by audience. The required-but-
-* possibly-empty shape of both `details` and `dev` is the discipline:
-* forgetting either field is a TypeScript error, and writing `''` is a
-* deliberate "I have nothing for that audience" decision.
-*
-* Concretely:
-*
-*   - `message`     One sentence. Caller-safe. Always rendered.
-*   - `details`     Longer caller-safe prose. About the request itself, the
-*                   contract, what the caller can do to fix it. Always
-*                   rendered. NEVER includes:
-*                     - sibling/neighbor enumeration (leaks namespace)
-*                     - filesystem paths or "agents/" / "skills/" / etc.
-*                       (leaks framework internals)
-*                     - source-code-level fix instructions ("add ... to your
-*                       agent definition") (caller can't act on these)
-*                     - build-time or runtime mechanics
-*   - `dev`         Longer dev-audience prose. Available alternatives,
-*                   filesystem layout, framework guidance, source-code-level
-*                   fix instructions. Rendered ONLY when FLUE_MODE=local.
-*
-* When in doubt, put information in `dev`. The default is conservative.
-*
-* ──── Conventions for new error classes ───────────────────────────────────
-*
-*   - Class name: PascalCase, suffixed with `Error`. E.g. `AgentNotFoundError`.
-*   - The class owns its `type` constant (snake_case). Set once in the
-*     subclass constructor, never passed by callers. Renaming the wire type
-*     is then a one-line change.
-*   - Constructor takes ONLY structured input data (the values used to build
-*     the message). The constructor assembles `message`, `details`, and
-*     `dev` from that data, so call sites never reinvent phrasing.
-*   - `details` and `dev` are both required strings. Pass `''` only when
-*     there's genuinely nothing more to say for that audience.
-*   - For HTTP errors, the class sets its own `status` (and `headers` where
-*     relevant). Callers do not pick HTTP status codes ad-hoc.
-*
-* Worked example (matches `AgentNotFoundError` below):
-*
-*     new AgentNotFoundError({ name, available });
-*     // builds:
-*     //   message: `Agent "foo" is not registered.`
-*     //   details: `Verify the agent name is correct.`
-*     //   dev:     `Available agents: "echo", "greeter". Agents are
-*     //            loaded from the workspace's "agents/" directory at
-*     //            build time. ...`
-*
-* The wire response in production omits `dev`; in `flue dev` / `flue run`
-* it includes `dev`. That separation is what lets the dev field be richly
-* helpful without leaking namespace state to public callers.
-*
-* Counter-example to avoid:
-*
-*     class AgentNotFoundError extends FlueHttpError {
-*       constructor(message: string) {                       // ✗ free-form
-*         super({                                            // ✗ wrong type
-*           type: 'agent_error',
-*           message,
-*           details: 'Available: "x", "y", "z"',             // ✗ leaks names
-*           dev: '',                                         // ✗ wasted channel
-*           status: 500,                                     // ✗ wrong status
-*         });
-*       }
-*     }
-*
-* The structured-constructor pattern below is what prevents that drift.
-*/
-/**
-* Format a list of items for inclusion in error details. Empty lists render
-* as the supplied fallback (default `(none)`), so messages read naturally
-* regardless of whether anything is registered.
-*
-* Module-private: only used by the concrete error subclasses below. Promote
-* to `export` if/when a real cross-file caller appears.
-*/
-function formatList(items, fallback = "(none)") {
-	if (items.length === 0) return fallback;
-	return items.map((item) => `"${String(item)}"`).join(", ");
-}
-/**
-* Base class for every error Flue throws. Do not instantiate directly in
-* application code — extend it via a subclass below. If a use case isn't
-* covered, add a new subclass here rather than throwing a raw `FlueError`.
-*/
-var FlueError = class extends Error {
-	type;
-	details;
-	dev;
-	meta;
-	cause;
-	constructor(options) {
-		super(options.message);
-		this.name = "FlueError";
-		this.type = options.type;
-		this.details = options.details;
-		this.dev = options.dev;
-		this.meta = options.meta;
-		this.cause = options.cause;
-	}
-};
-/**
-* Base class for HTTP-layer errors. Adds `status` and optional `headers`.
-* Subclasses set these in the `super({...})` call so the call site doesn't
-* have to think about HTTP semantics.
-*/
-var FlueHttpError = class extends FlueError {
-	status;
-	headers;
-	constructor(options) {
-		super(options);
-		this.name = "FlueHttpError";
-		this.status = options.status;
-		this.headers = options.headers;
-	}
-};
-var MethodNotAllowedError = class extends FlueHttpError {
-	constructor({ method, allowed }) {
-		super({
-			type: "method_not_allowed",
-			message: `HTTP method ${method} is not allowed on this endpoint.`,
-			details: `This endpoint accepts ${formatList(allowed)} only.`,
-			dev: "",
-			status: 405,
-			headers: { Allow: allowed.join(", ") }
-		});
-	}
-};
-var UnsupportedMediaTypeError = class extends FlueHttpError {
-	constructor({ received }) {
-		const detailLines = [];
-		if (received) detailLines.push(`Received Content-Type: "${received}".`);
-		else detailLines.push(`No Content-Type header was sent.`);
-		detailLines.push("Send the request body as JSON with the header \"Content-Type: application/json\", or omit the body entirely (and the Content-Type header) if the request doesn't have a payload.");
-		super({
-			type: "unsupported_media_type",
-			message: `Request body must be sent as application/json.`,
-			details: detailLines.join("\n"),
-			dev: "",
-			status: 415
-		});
-	}
-};
-var InvalidJsonError = class extends FlueHttpError {
-	constructor({ parseError }) {
-		super({
-			type: "invalid_json",
-			message: `Request body is not valid JSON.`,
-			details: `The JSON parser reported: ${parseError}\nVerify the body is well-formed JSON, or omit the body entirely if the request doesn't have a payload.`,
-			dev: "",
-			status: 400
-		});
-	}
-};
-var AgentNotFoundError = class extends FlueHttpError {
-	constructor({ name, available }) {
-		super({
-			type: "agent_not_found",
-			message: `Agent "${name}" is not registered.`,
-			details: `Verify the agent name is correct.`,
-			dev: `Available agents: ${formatList(available)}.\nAgents are loaded from the workspace's "agents/" directory at build time. Verify the agent file is present in the workspace being served.`,
-			status: 404
-		});
-	}
-};
-var AgentNotWebhookError = class extends FlueHttpError {
-	constructor({ name }) {
-		super({
-			type: "agent_not_webhook",
-			message: `Agent "${name}" is not web-accessible.`,
-			details: `This endpoint is not exposed over HTTP.`,
-			dev: "This agent has no webhook trigger configured. To expose it, add a webhook trigger to its definition (`triggers: { webhook: true }`). Trigger-less agents remain invokable via \"flue run\" in local mode.",
-			status: 404
-		});
-	}
-};
-var RouteNotFoundError = class extends FlueHttpError {
-	constructor({ method, path }) {
-		super({
-			type: "route_not_found",
-			message: `No route matches ${method} ${path}.`,
-			details: `Webhook agents are served at POST /agents/<name>/<id>.`,
-			dev: "",
-			status: 404
-		});
-	}
-};
-var InvalidRequestError = class extends FlueHttpError {
-	constructor({ reason }) {
-		super({
-			type: "invalid_request",
-			message: `Request is malformed.`,
-			details: reason,
-			dev: "",
-			status: 400
-		});
-	}
-};
-
-//#endregion
-//#region src/error-utils.ts
-/**
-* Error framework for Flue.
-*
-* This file holds the abstract scaffolding (renderers, helpers, request-
-* parsing utilities, type guard, logger) that supports the concrete error
-* subclasses defined in `errors.ts`. The two-file split is deliberate:
-*
-*   - `errors.ts` is the *vocabulary*: the `FlueError` base class plus every
-*     concrete subclass Flue can throw. That's the file new contributors
-*     touch when they need to add a new error.
-*
-*   - `error-utils.ts` (this file) is the *framework*: the renderers that
-*     turn errors into HTTP responses and SSE event data, the type guard,
-*     the logger, and the request-parsing utilities. This file rarely
-*     changes.
-*
-* Application code should NOT instantiate `FlueError` directly. Always reach
-* for a subclass from `errors.ts`. If no existing subclass fits, add one
-* there. This is what keeps message tone, detail level, and field naming
-* consistent across the codebase.
-*
-* Wire envelope (HTTP body + SSE `data:` payload for error events):
-*
-*     {
-*       "error": {
-*         "type":    "...",
-*         "message": "...",
-*         "details": "...",
-*         "dev":     "..."   // present only in local/dev mode AND when non-empty
-*       }
-*     }
-*
-* Field rules:
-*   - `type`, `message`, `details` are always present on the wire.
-*   - `dev` is gated by `FLUE_MODE === 'local'` (set by `flue run` and
-*     `flue dev --target node`). Even in dev mode, `dev` is omitted when
-*     the error class set it to `''` — so its presence is not a reliable
-*     signal of mode by itself; clients should not depend on it that way.
-*     See `errors.ts` for the two-audience rationale.
-*   - `meta` is included on the wire only when an error subclass sets it
-*     (rare).
-*   - `cause` is never included on the wire (it's logged server-side only).
-*/
-function isFlueError(value) {
-	return value instanceof FlueError;
-}
-/**
-* Structured error logger. Used by the HTTP and SSE renderers below to log
-* unknown/wrapped errors before rendering a generic envelope.
-*
-* Module-private for now: when an external call site appears we can promote
-* to `export` and decide the right shape for `warn`/`info` (FlueError
-* subclasses with severity? plain strings? structured data?) — rather than
-* committing to a shape now without any usage to validate it.
-*/
-function formatForLog(prefix, err) {
-	if (isFlueError(err)) {
-		const lines = [`${prefix} [${err.type}] ${err.message}`];
-		if (err.details) for (const line of err.details.split("\n")) lines.push(`  ${line}`);
-		if (err.dev) for (const line of err.dev.split("\n")) lines.push(`  ${line}`);
-		if (err.cause !== void 0) lines.push(`  cause: ${err.cause instanceof Error ? err.cause.stack ?? err.cause.message : String(err.cause)}`);
-		return lines.join("\n");
-	}
-	if (err instanceof Error) return `${prefix} ${err.stack ?? err.message}`;
-	return `${prefix} ${String(err)}`;
-}
-const flueLog = { error(err) {
-	console.error(formatForLog("[flue]", err));
-} };
-/**
-* Detect whether the server is running in local/dev mode. Gates whether the
-* `dev` field is included on the wire — see the convention doc in `errors.ts`.
-*
-* Currently keyed off the `FLUE_MODE=local` env var, which is set by
-* `flue run` and `flue dev --target node`. On Cloudflare workers there is
-* no global `process` and no current "local mode" plumbing for the worker —
-* so deployed CF and `flue dev --target cloudflare` both currently render
-* the prod envelope. Threading a dev-mode signal through to the worker
-* fetch handler is left as a follow-up.
-*/
-function isDevMode() {
-	return typeof process !== "undefined" && process.env?.FLUE_MODE === "local";
-}
-function envelope(err) {
-	const out = { error: {
-		type: err.type,
-		message: err.message,
-		details: err.details
-	} };
-	if (isDevMode() && err.dev) out.error.dev = err.dev;
-	if (err.meta) out.error.meta = err.meta;
-	return out;
-}
-const GENERIC_INTERNAL = { error: {
-	type: "internal_error",
-	message: "An internal error occurred.",
-	details: "The server encountered an unexpected error while handling this request."
-} };
-/**
-* Render any thrown value into a `Response` with the canonical Flue error
-* envelope. Unknown / non-Flue errors are logged in full and rendered as a
-* generic 500 with no message leaked.
-*/
-function toHttpResponse(err) {
-	if (isFlueError(err)) {
-		const isHttp = err instanceof FlueHttpError;
-		const status = isHttp ? err.status : 500;
-		const headers = { "content-type": "application/json" };
-		if (isHttp && err.headers) Object.assign(headers, err.headers);
-		if (!isHttp) flueLog.error(err);
-		return new Response(JSON.stringify(envelope(err)), {
-			status,
-			headers
-		});
-	}
-	flueLog.error(err);
-	return new Response(JSON.stringify(GENERIC_INTERNAL), {
-		status: 500,
-		headers: { "content-type": "application/json" }
-	});
-}
-/**
-* Render any thrown value into a JSON string suitable for the `data:` line of
-* an SSE `error` event. Same envelope as `toHttpResponse`. Unknown / non-Flue
-* errors are logged and replaced with a generic envelope.
-*/
-function toSseData(err) {
-	if (isFlueError(err)) {
-		if (!(err instanceof FlueHttpError)) flueLog.error(err);
-		return JSON.stringify({
-			type: "error",
-			...envelope(err)
-		});
-	}
-	flueLog.error(err);
-	return JSON.stringify({
-		type: "error",
-		...GENERIC_INTERNAL
-	});
-}
-/**
-* Parse a request body as JSON. Returns `{}` for genuinely empty bodies
-* (Content-Length: 0 or missing) so that webhook agents which don't accept
-* a payload can be invoked without one.
-*
-* Throws `UnsupportedMediaTypeError` if a body is present without
-* `application/json` content-type, and `InvalidJsonError` if the body is
-* present but unparseable.
-*/
-async function parseJsonBody(request) {
-	const contentLengthHeader = request.headers.get("content-length");
-	const contentLength = contentLengthHeader === null ? null : Number(contentLengthHeader);
-	const contentType = request.headers.get("content-type");
-	if (contentLength === 0 || contentLengthHeader === null && contentType === null) return {};
-	if (!contentType || !contentType.toLowerCase().includes("application/json")) throw new UnsupportedMediaTypeError({ received: contentType });
-	let text;
-	try {
-		text = await request.text();
-	} catch (err) {
-		throw new InvalidJsonError({ parseError: err instanceof Error ? err.message : String(err) });
-	}
-	if (text.trim() === "") return {};
-	try {
-		return JSON.parse(text);
-	} catch (err) {
-		throw new InvalidJsonError({ parseError: err instanceof Error ? err.message : String(err) });
-	}
-}
-function validateAgentRequest(opts) {
-	if (opts.method !== "POST") throw new MethodNotAllowedError({
-		method: opts.method,
-		allowed: ["POST"]
-	});
-	if (opts.name.trim() === "" || opts.id.trim() === "") throw new InvalidRequestError({ reason: "Webhook URLs must have the shape /agents/<name>/<id> with non-empty segments." });
-	if (!opts.registeredAgents.includes(opts.name)) throw new AgentNotFoundError({
-		name: opts.name,
-		available: opts.registeredAgents
-	});
-	if (!opts.allowNonWebhook && !opts.webhookAgents.includes(opts.name)) throw new AgentNotWebhookError({ name: opts.name });
-}
-
-//#endregion
 //#region src/internal.ts
 /**
 * Internal runtime helpers consumed by the generated server entry point.
@@ -433,24 +19,24 @@ function validateAgentRequest(opts) {
 * User agent code should never import from here.
 */
 /**
-* Resolve a `provider/model-id` string into a pi-ai `Model` object.
-* Lives here (rather than in the generated entry point) so that user
-* projects don't have to declare `@mariozechner/pi-ai` as a direct
-* dependency — wrangler's bundler resolves bare specifiers from the entry
-* file's location, which on pnpm-isolated installs doesn't see Flue's
-* transitive deps. Centralizing the resolver here keeps `_entry.ts`
-* dependency-free apart from `@flue/sdk/*`.
+* Resolve `provider/model-id` to a pi-ai Model. Registered URL prefixes win
+* over pi-ai's catalog; configureProvider settings patch the resolved Model.
 */
-function resolveModel(model, providers) {
+function resolveModel(model) {
 	if (model === false || model === void 0) return void 0;
 	const modelString = model;
 	const slash = modelString.indexOf("/");
 	if (slash === -1) throw new Error(`[flue] Invalid model "${modelString}". Use the "provider/model-id" format (e.g. "anthropic/claude-haiku-4-5").`);
 	const provider = modelString.slice(0, slash);
 	const modelId = modelString.slice(slash + 1);
+	const built = resolveRegisteredModel(provider, modelId);
+	if (built) {
+		if (modelId === "") throw new Error(`[flue] Invalid model "${modelString}". The "${provider}/" prefix is registered via registerProvider(), but no model id was given. Use "${provider}/<model-id>".`);
+		return applyProviderSettings(built, getProviderConfiguration(built.provider));
+	}
 	const resolved = getModel(provider, modelId);
-	if (!resolved) throw new Error(`[flue] Unknown model "${modelString}". Provider "${provider}" / model id "${modelId}" is not registered with @mariozechner/pi-ai.`);
-	return applyProviderSettings(resolved, providers?.[provider]);
+	if (!resolved) throw new Error(`[flue] Unknown model "${modelString}". Provider "${provider}" / model id "${modelId}" is not registered with @mariozechner/pi-ai or via registerProvider().`);
+	return applyProviderSettings(resolved, getProviderConfiguration(provider));
 }
 function applyProviderSettings(model, providerSettings) {
 	if (!providerSettings) return model;
@@ -468,4 +54,4 @@ function applyProviderSettings(model, providerSettings) {
 }
 
 //#endregion
-export { AgentNotFoundError, InMemorySessionStore, InvalidRequestError, MethodNotAllowedError, RouteNotFoundError, bashFactoryToSessionEnv, createFlueContext, parseJsonBody, resolveModel, toHttpResponse, toSseData, validateAgentRequest };
+export { InMemorySessionStore, bashFactoryToSessionEnv, configureFlueRuntime, createDefaultFlueApp, createFlueContext, handleAgentRequest, resolveModel };

package/dist/{mcp-CcRxAwXW.d.mts → mcp-C3UBXVkR.d.mts}

@@ -1,4 +1,4 @@
-import { P as ToolDef } from "./types-DGpyKMFm.mjs";
+import { L as ToolDef } from "./types-BAmV4f3Q.mjs";
 
 //#region src/mcp.d.ts
 type McpTransport = 'streamable-http' | 'sse';

package/dist/{mcp-DmDTeVXW.mjs → mcp-DM6yv_Qc.mjs}

@@ -1,6 +1,7 @@
-import { r as discoverSessionContext } from "./agent-Cahthgu3.mjs";
-import { a as assertRoleExists, n as Session, o as createScopedEnv, r as deleteSessionTree, s as mergeCommands } from "./session-DlwIt7wq.mjs";
-import { createCwdSessionEnv } from "./sandbox.mjs";
+import { u as discoverSessionContext } from "./result-K1IRhWKM.mjs";
+import { n as createCallHandle } from "./abort-Bg3qsAkU.mjs";
+import { a as assertRoleExists, n as Session, r as deleteSessionTree } from "./session-CFOByKnM.mjs";
+import { createCwdSessionEnv, createFlueFs } from "./sandbox.mjs";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 
@@ -12,43 +13,35 @@ var AgentClient = class {
 		create: (id, options) => this.openSession(id, "create", options),
 		delete: (id) => this.deleteSession(id)
 	};
+	fs;
 	openSessions = /* @__PURE__ */ new Map();
-	destroyed = false;
-	constructor(id, config, env, store, eventCallback, agentCommands = [], agentTools = []) {
+	constructor(id, config, env, store, eventCallback, agentTools = []) {
 		this.id = id;
 		this.config = config;
 		this.env = env;
 		this.store = store;
 		this.eventCallback = eventCallback;
-		this.agentCommands = agentCommands;
 		this.agentTools = agentTools;
+		this.fs = createFlueFs(env);
 	}
 	async session(id, options) {
 		return this.openSession(id, "get-or-create", options);
 	}
-	async shell(command, options) {
-		this.assertActive();
-		const effectiveCommands = mergeCommands(this.agentCommands, options?.commands);
-		const result = await (await createScopedEnv(this.env, effectiveCommands)).exec(command, {
-			env: options?.env,
-			cwd: options?.cwd,
-			timeout: options?.timeout
+	shell(command, options) {
+		return createCallHandle(options?.signal, async (signal) => {
+			const result = await this.env.exec(command, {
+				env: options?.env,
+				cwd: options?.cwd,
+				signal
+			});
+			return {
+				stdout: result.stdout,
+				stderr: result.stderr,
+				exitCode: result.exitCode
+			};
 		});
-		return {
-			stdout: result.stdout,
-			stderr: result.stderr,
-			exitCode: result.exitCode
-		};
-	}
-	async destroy() {
-		if (this.destroyed) return;
-		this.destroyed = true;
-		for (const session of Array.from(this.openSessions.values())) session.close();
-		this.openSessions.clear();
-		await this.env.cleanup();
 	}
 	async openSession(id, mode, options) {
-		this.assertActive();
 		assertRoleExists(this.config.roles, options?.role);
 		const sessionId = normalizeSessionId(id);
 		const open = this.openSessions.get(sessionId);
@@ -74,7 +67,6 @@ var AgentClient = class {
 			store: this.store,
 			existingData: data,
 			onAgentEvent: this.eventCallback,
-			agentCommands: this.agentCommands,
 			agentTools: this.agentTools,
 			sessionRole: options?.role,
 			taskDepth: 0,
@@ -85,7 +77,6 @@ var AgentClient = class {
 		return session;
 	}
 	async deleteSession(id) {
-		this.assertActive();
 		const sessionId = normalizeSessionId(id);
 		const open = this.openSessions.get(sessionId);
 		if (open) {
@@ -95,7 +86,6 @@ var AgentClient = class {
 		await deleteSessionTree(this.store, createSessionStorageKey(this.id, sessionId));
 	}
 	async createTaskSession(options) {
-		this.assertActive();
 		assertRoleExists(this.config.roles, options.role);
 		const sessionId = `task:${options.parentSessionId}:${options.taskId}`;
 		const taskEnv = options.cwd ? createCwdSessionEnv(options.parentEnv, options.parentEnv.resolvePath(options.cwd)) : options.parentEnv;
@@ -130,16 +120,12 @@ var AgentClient = class {
 			store: this.store,
 			existingData: data,
 			onAgentEvent: eventCallback,
-			agentCommands: options.commands,
 			agentTools: this.agentTools,
 			sessionRole: options.role,
 			taskDepth: options.depth,
 			createTaskSession: (childOptions) => this.createTaskSession(childOptions)
 		});
 	}
-	assertActive() {
-		if (this.destroyed) throw new Error(`[flue] Agent "${this.id}" has been destroyed.`);
-	}
 };
 function normalizeSessionId(id) {
 	return id ?? DEFAULT_SESSION_ID;

package/dist/node/index.d.mts

@@ -1,14 +1,10 @@
-import { l as Command } from "../types-DGpyKMFm.mjs";
-import { t as CommandExecutor } from "../command-helpers-eVG1-Iru.mjs";
-import { execFile } from "node:child_process";
+import { O as SessionEnv } from "../types-BAmV4f3Q.mjs";
 
-//#region src/node/define-command.d.ts
-/**
- * Options forwarded directly to Node's `child_process.execFile`. Full pass-through.
- */
-type CommandOptions = NonNullable<Parameters<typeof execFile>[2]>;
-declare function defineCommand(name: string): Command;
-declare function defineCommand(name: string, options: CommandOptions): Command;
-declare function defineCommand(name: string, execute: CommandExecutor): Command;
+//#region src/node/local-env.d.ts
+interface LocalSessionEnvOptions {
+  /** Working directory. Defaults to `process.cwd()`. */
+  cwd?: string;
+}
+declare function createLocalSessionEnv(options?: LocalSessionEnvOptions): SessionEnv;
 //#endregion
-export { type CommandOptions, defineCommand };
+export { type LocalSessionEnvOptions, createLocalSessionEnv };