@statelyai/agent 1.1.6 → 2.0.0-alpha.6

package/dist/ai-sdk.mjs

@@ -0,0 +1,241 @@
+import { G as isStandardSchema, T as getAgentOutputMode, l as renderDecisionAttempts, x as buildEnvelopeSchema } from "./decision-D1654JdD.mjs";
+import { Output, generateText, stepCountIs, streamText, tool } from "ai";
+//#region src/ai-sdk/index.ts
+/**
+* Maps an {@link AgentTools} map onto AI SDK `tool()` definitions. A tool that
+* already carries its own Standard Schema `inputSchema` — an AI SDK
+* `tool({...})`, or any equivalent descriptor — is passed through **unchanged**,
+* so the SDK applies its own validation, calls `execute(input, options)`, and
+* every extra property (`providerOptions`, `toModelOutput`, …) survives. A bare
+* `AgentToolExecute` function becomes a tool with an unconstrained input schema;
+* a minimal descriptor with no readable schema is converted with a permissive
+* fallback. Used internally by {@link toAiSdkCallSettings}; exported for callers
+* building AI SDK calls by hand outside `createAiSdkExecutors`.
+*/
+function toAiSdkTools(tools) {
+	const entries = [];
+	for (const [name, descriptor] of Object.entries(tools)) {
+		if (!descriptor) continue;
+		if (typeof descriptor === "function") {
+			entries.push([name, tool({
+				inputSchema: unknownSchema,
+				execute: (input) => descriptor(input)
+			})]);
+			continue;
+		}
+		if (isStandardSchema(descriptor.inputSchema)) {
+			entries.push([name, descriptor]);
+			continue;
+		}
+		const inputSchema = descriptor.inputSchema ?? descriptor.schemas?.input;
+		const toolOptions = {
+			description: descriptor.description,
+			inputSchema: inputSchema ? inputSchema : unknownSchema
+		};
+		if (descriptor.execute) {
+			entries.push([name, tool({
+				...toolOptions,
+				execute: (input) => descriptor.execute?.(input)
+			})]);
+			continue;
+		}
+		entries.push([name, tool(toolOptions)]);
+	}
+	return Object.fromEntries(entries);
+}
+function maxStepsSetting(request) {
+	return typeof request.metadata?.maxSteps === "number" ? { stopWhen: stepCountIs(request.metadata.maxSteps) } : {};
+}
+const unknownSchema = { "~standard": {
+	version: 1,
+	vendor: "statelyai-agent",
+	validate: (value) => ({ value }),
+	jsonSchema: { input: () => ({}) }
+} };
+/**
+* Identity helper for a `models` map whose value is exported. Returns the map
+* unchanged, but types it as {@link AiSdkModelMap}`<keyof T & string>` — a
+* portable, nameable type — so an exported `const models = defineModels({...})`
+* needs no `Record<'a' | 'b', LanguageModel>` annotation and never triggers
+* TS2742 ("inferred type cannot be named without a reference to …"). The exact
+* ref keys survive, so `createAiSdkExecutors({ models })` and
+* `setupAgent({ models })` still infer/autocomplete them.
+*
+* @example
+* ```ts
+* export const models = defineModels({
+*   quick: openai('gpt-5.4-mini'),
+*   deep: openai('gpt-5.4'),
+* });
+* // typeof models === AiSdkModelMap<'quick' | 'deep'>
+* ```
+*/
+function defineModels(models) {
+	return models;
+}
+function resolveAiSdkModel(options, modelRef) {
+	if (options.resolveModel) return options.resolveModel(modelRef);
+	const models = options.models;
+	if (!models) throw new Error(`createAiSdkExecutors: no model resolver configured for '${modelRef}'.`);
+	const model = models[modelRef];
+	if (!model) throw new Error(`createAiSdkExecutors: unknown model '${modelRef}'.`);
+	return model;
+}
+/**
+* AI SDK request-mapping settings shared by `generateText`/`streamText`.
+* `AgentTextRequest.messages` (`AgentMessage[]`) and AI SDK's `ModelMessage[]`
+* are structurally compatible by design (§1 of docs/p0-design.md) — the cast
+* below is a typed identity mapping, not a semantic conversion.
+*/
+function toAiSdkCallSettings(request) {
+	const messages = request.messages;
+	return {
+		system: request.system,
+		...messages ? { messages } : { prompt: request.prompt ?? "" },
+		temperature: request.temperature,
+		maxOutputTokens: request.maxOutputTokens,
+		topP: request.topP,
+		topK: request.topK,
+		seed: request.seed,
+		stopSequences: request.stopSequences,
+		tools: request.tools ? toAiSdkTools(request.tools) : void 0,
+		toolChoice: toAiSdkToolChoice(request.toolChoice)
+	};
+}
+/** Maps an {@link AgentToolChoice} to AI SDK's tool-choice shape — `{ type: 'tool'; name }` becomes `{ type: 'tool'; toolName }`; `'auto'`/`'none'`/`'required'`/`undefined` pass through unchanged. */
+function toAiSdkToolChoice(toolChoice) {
+	return typeof toolChoice === "object" ? {
+		type: "tool",
+		toolName: toolChoice.name
+	} : toolChoice;
+}
+/** `true` when the request should use AI SDK structured `Output.object`. */
+function isStructuredOutputRequest(request) {
+	return getAgentOutputMode(request.outputSchema) === "structured";
+}
+/**
+* The canonical Vercel AI SDK adapter: builds the `{ generateText, streamText,
+* decide }` executor set consumed by `runAgent`/`executeAgentRequest`. `ai`
+* must not become a dependency of core `src/` files — this subpath is the one
+* place it's imported, and callers must supply their own model resolver so no
+* concrete provider package (e.g. `@ai-sdk/openai`) becomes a dependency here
+* either.
+*
+* @example
+* ```ts
+* const executors = createAiSdkExecutors({ models: { quick: openai('gpt-5.4-mini') } });
+* const result = await runAgent(machine, { input, executors });
+* ```
+*/
+function createAiSdkExecutors(options) {
+	const generateText$1 = async (request, info) => {
+		const common = {
+			model: resolveAiSdkModel(options, request.model),
+			abortSignal: info?.signal,
+			...toAiSdkCallSettings(request),
+			...maxStepsSetting(request)
+		};
+		if (isStructuredOutputRequest(request)) {
+			const envelope = buildEnvelopeSchema(request.outputSchema, { reasoning: request.reasoning });
+			const result = await generateText({
+				...common,
+				output: Output.object({ schema: envelope })
+			});
+			const { result: output, reasoning } = result.output;
+			return {
+				output,
+				...reasoning !== void 0 ? { reasoning } : {},
+				usage: result.usage,
+				finishReason: result.finishReason,
+				toolCalls: result.toolCalls,
+				toolResults: result.toolResults
+			};
+		}
+		const result = await generateText(common);
+		return {
+			output: result.text,
+			usage: result.usage,
+			finishReason: result.finishReason,
+			toolCalls: result.toolCalls,
+			toolResults: result.toolResults
+		};
+	};
+	const streamText$1 = async (request, info) => {
+		const result = streamText({
+			model: resolveAiSdkModel(options, request.model),
+			abortSignal: info?.signal,
+			...toAiSdkCallSettings(request),
+			...maxStepsSetting(request)
+		});
+		for await (const chunk of result.textStream) info?.onChunk?.(chunk);
+		return {
+			output: await result.text,
+			usage: await result.usage,
+			finishReason: await result.finishReason
+		};
+	};
+	const decide = async (request) => {
+		const model = resolveAiSdkModel(options, request.model);
+		const tools = toAiSdkEventTools(request.events);
+		const messages = toDecisionMessages(request);
+		const result = await generateText({
+			model,
+			abortSignal: request.signal,
+			system: request.system,
+			...messages ? { messages } : { prompt: request.prompt ?? "" },
+			tools,
+			toolChoice: "required",
+			stopWhen: stepCountIs(1),
+			temperature: request.temperature,
+			maxOutputTokens: request.maxOutputTokens,
+			topP: request.topP,
+			topK: request.topK,
+			seed: request.seed,
+			stopSequences: request.stopSequences
+		});
+		const toolCall = result.toolCalls[0];
+		if (!toolCall) throw new Error("createAiSdkExecutors: decide — model did not call an event tool.");
+		const chosenEvent = request.events.find((event) => event.toolName === toolCall.toolName);
+		if (!chosenEvent) throw new Error(`createAiSdkExecutors: decide — model called unknown tool '${toolCall.toolName}'.`);
+		return {
+			event: {
+				...toolCall.input && typeof toolCall.input === "object" ? toolCall.input : {},
+				type: chosenEvent.type
+			},
+			usage: result.usage,
+			finishReason: result.finishReason
+		};
+	};
+	return {
+		generateText: generateText$1,
+		streamText: streamText$1,
+		decide
+	};
+}
+/** One AI SDK `tool()` per candidate event — the "tool-per-event +
+* toolChoice: 'required'" recipe from docs/p0-design.md §2.6. */
+function toAiSdkEventTools(events) {
+	return Object.fromEntries(events.map((event) => [event.toolName, tool({
+		description: `Choose the '${event.type}' move.`,
+		inputSchema: event.inputSchema ? event.inputSchema : unknownSchema
+	})]));
+}
+/**
+* Messages for a decision request, with prior failed `attempts` (§2.6)
+* rendered as appended user messages (via core's {@link renderDecisionAttempts})
+* so retries converge. Core never rewrites prompts — this is adapter business.
+*/
+function toDecisionMessages(request) {
+	if (!request.messages && request.attempts.length === 0) return;
+	const messages = [...request.messages ?? (request.prompt !== void 0 ? [{
+		role: "user",
+		content: request.prompt
+	}] : [])];
+	for (const attempt of renderDecisionAttempts(request)) messages.push({
+		role: "user",
+		content: attempt.content
+	});
+	return messages;
+}
+//#endregion
+export { createAiSdkExecutors, defineModels, isStructuredOutputRequest, toAiSdkCallSettings, toAiSdkEventTools, toAiSdkToolChoice, toAiSdkTools, toDecisionMessages };

package/dist/cli.cjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+const require_src = require("./src-wBfi-kTA.cjs");
+let node_fs = require("node:fs");
+//#region src/cli.ts
+/**
+* `statelyai-agent lint <workflow.json>` — keyless static verification for an
+* agent machine authored as data (an {@link AgentWorkflowConfig} JSON file).
+*
+* The library bundles no JSON Schema engine, so the CLI lints STRUCTURE ONLY:
+* it compiles the config with a permissive pass-through schema compiler (each
+* JSON Schema is kept as-is for structural checks, validation is a no-op) and
+* runs {@link lintAgentMachine}. Exits `1` on any error-severity finding.
+*
+* For full schema-aware linting, import the API and compile with a real engine:
+* `lintAgentMachine(setupAgent.fromConfig(config, { compileSchema }))`.
+*
+* @module
+*/
+function stubCompileSchema(jsonSchema) {
+	return { "~standard": {
+		version: 1,
+		vendor: "statelyai-agent-cli",
+		validate: (value) => ({ value }),
+		jsonSchema: { input: () => jsonSchema }
+	} };
+}
+function printUsage() {
+	process.stderr.write("Usage: statelyai-agent lint <workflow.json> [--no-schemas]\n\n  Statically verifies an agent-machine JSON config (structure-only).\n  Exits 1 on any error-severity finding.\n");
+}
+function main(argv) {
+	const args = argv.slice(2);
+	const command = args[0];
+	const file = args.find((arg, index) => index > 0 && !arg.startsWith("-"));
+	if (command !== "lint" || !file) {
+		printUsage();
+		return 2;
+	}
+	let config;
+	try {
+		config = JSON.parse((0, node_fs.readFileSync)(file, "utf8"));
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: could not read/parse '${file}': ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	let machine;
+	try {
+		machine = require_src.setupAgent.fromConfig(config, { compileSchema: stubCompileSchema });
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: '${file}' is not a valid agent-machine config: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	const diagnostics = require_src.lintAgentMachine(machine);
+	const errors = diagnostics.filter((d) => d.severity === "error");
+	const warnings = diagnostics.filter((d) => d.severity === "warning");
+	for (const d of diagnostics) {
+		const label = d.severity === "error" ? "error" : "warn ";
+		process.stdout.write(`  ${label}  ${d.code}  ${d.path}\n         ${d.message}\n`);
+	}
+	process.stdout.write(`\n${file}: ${errors.length} error(s), ${warnings.length} warning(s) (structure-only; schemas not compiled).\n`);
+	return errors.length > 0 ? 1 : 0;
+}
+process.exit(main(process.argv));
+//#endregion

package/dist/cli.d.cts

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

package/dist/cli.d.mts

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

package/dist/cli.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { r as lintAgentMachine, v as setupAgent } from "./src-CEa947Dm.mjs";
+import { readFileSync } from "node:fs";
+//#region src/cli.ts
+/**
+* `statelyai-agent lint <workflow.json>` — keyless static verification for an
+* agent machine authored as data (an {@link AgentWorkflowConfig} JSON file).
+*
+* The library bundles no JSON Schema engine, so the CLI lints STRUCTURE ONLY:
+* it compiles the config with a permissive pass-through schema compiler (each
+* JSON Schema is kept as-is for structural checks, validation is a no-op) and
+* runs {@link lintAgentMachine}. Exits `1` on any error-severity finding.
+*
+* For full schema-aware linting, import the API and compile with a real engine:
+* `lintAgentMachine(setupAgent.fromConfig(config, { compileSchema }))`.
+*
+* @module
+*/
+function stubCompileSchema(jsonSchema) {
+	return { "~standard": {
+		version: 1,
+		vendor: "statelyai-agent-cli",
+		validate: (value) => ({ value }),
+		jsonSchema: { input: () => jsonSchema }
+	} };
+}
+function printUsage() {
+	process.stderr.write("Usage: statelyai-agent lint <workflow.json> [--no-schemas]\n\n  Statically verifies an agent-machine JSON config (structure-only).\n  Exits 1 on any error-severity finding.\n");
+}
+function main(argv) {
+	const args = argv.slice(2);
+	const command = args[0];
+	const file = args.find((arg, index) => index > 0 && !arg.startsWith("-"));
+	if (command !== "lint" || !file) {
+		printUsage();
+		return 2;
+	}
+	let config;
+	try {
+		config = JSON.parse(readFileSync(file, "utf8"));
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: could not read/parse '${file}': ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	let machine;
+	try {
+		machine = setupAgent.fromConfig(config, { compileSchema: stubCompileSchema });
+	} catch (error) {
+		process.stderr.write(`statelyai-agent: '${file}' is not a valid agent-machine config: ${error instanceof Error ? error.message : String(error)}\n`);
+		return 2;
+	}
+	const diagnostics = lintAgentMachine(machine);
+	const errors = diagnostics.filter((d) => d.severity === "error");
+	const warnings = diagnostics.filter((d) => d.severity === "warning");
+	for (const d of diagnostics) {
+		const label = d.severity === "error" ? "error" : "warn ";
+		process.stdout.write(`  ${label}  ${d.code}  ${d.path}\n         ${d.message}\n`);
+	}
+	process.stdout.write(`\n${file}: ${errors.length} error(s), ${warnings.length} warning(s) (structure-only; schemas not compiled).\n`);
+	return errors.length > 0 ? 1 : 0;
+}
+process.exit(main(process.argv));
+//#endregion
+export {};