@agimon-ai/po-codemode 0.0.1-alpha.2 → 0.0.1-alpha.4

package/dist/extensions/server.mjs

@@ -1,9 +1,13 @@
-import { n as createCodemodeRegistry, t as createCodemodeTools } from "../codemodeTools-BdwOARH8.mjs";
+import { n as createCodemodeRegistry, t as createCodemodeTools } from "../codemodeTools-D7CcAB18.mjs";
 import { PO_CODEMODE_CONTRACT, PO_CODEMODE_SERVICE } from "@agimon-ai/po-core/codemode";
+import { Type } from "typebox";
 import { PO_SERVER_SCOPE_SERVICE, composeServerProviderOverrides, defineServerPlugin, packageResourcePath, readPackageResource, requirePoServerScope } from "@agimon-ai/po-core/serverPlugin";
 import { composeRootHooks, composeRootInjects, defineResource, defineRoot, defineServerTool, defineServiceContract } from "@agimon-ai/po-core/extensionFile";
-import { BACKGROUND_CONTEXT, PO_SESSION_FILES_SERVICE, getOrThrow, readPoFs, readPoIsolate } from "@agimon-ai/po-core/platform";
-import { PO_HELP_WHEN } from "@agimon-ai/po-core/help";
+import { PO_CONFIG_SERVICE } from "@agimon-ai/po-config";
+import { BACKGROUND_CONTEXT, PO_SESSION_FILES_SERVICE, PO_SHELL_SERVICE, getOrThrow, readPoFs, readPoIsolate, readPoNpm, withAbortSignal } from "@agimon-ai/po-core/platform";
+import { readMajorModesConfig, readPackageConfigurations } from "@agimon-ai/po-config/majorModes";
+import { Check } from "typebox/value";
+import { Check as Check$1, Errors, Meta } from "typebox/schema";
 //#region src/services/codemodeScripts/index.ts
 const SESSION_FOLDER = "codemode";
 const SESSION_PREFIX = "session:";
@@ -113,9 +117,377 @@ var FileSystemCodemodeScriptsService = class {
 	}
 };
 //#endregion
+//#region src/schemas/packageConfig.ts
+const CODEMODE_PACKAGE = "@agimon-ai/po-codemode";
+const CodemodePackageConfigSchema = Type.Object({ llmModel: Type.Optional(Type.String({
+	pattern: "^[^/\\s]+/\\S+$",
+	maxLength: 256
+})) }, { additionalProperties: false });
+//#endregion
+//#region src/services/llmConfig/index.ts
+const PO_CODEMODE_LLM_CONFIG_SERVICE = "po/codemode-llm-config";
+/** Session policy is loaded once per immutable Po config snapshot, including failed loads. */
+var LlmConfigService = class {
+	io;
+	snapshot;
+	loads = /* @__PURE__ */ new WeakMap();
+	constructor(io) {
+		this.io = io;
+	}
+	bind(snapshot) {
+		this.snapshot = snapshot;
+		return () => {
+			if (this.snapshot === snapshot) this.snapshot = void 0;
+		};
+	}
+	current() {
+		if (!this.snapshot) return Promise.resolve({});
+		const snapshot = this.snapshot();
+		let load = this.loads.get(snapshot);
+		if (!load) {
+			load = this.load(snapshot);
+			this.loads.set(snapshot, load);
+		}
+		return load;
+	}
+	async load(snapshot) {
+		if (!snapshot.harness.root) return {};
+		const { environment, homeDirectory } = this.io;
+		const fs = this.io.fs();
+		if (!fs || !homeDirectory) throw new Error("Code mode LLM configuration requires host filesystem and home.");
+		const modes = await readMajorModesConfig(fs, snapshot.harness.root, BACKGROUND_CONTEXT, {
+			environment,
+			homeDirectory
+		});
+		const configurations = await readPackageConfigurations(fs, modes, [...snapshot.harness.layers], CODEMODE_PACKAGE, BACKGROUND_CONTEXT);
+		let merged = {};
+		for (const entry of configurations) {
+			if (!Check(CodemodePackageConfigSchema, entry.config)) throw new TypeError("Invalid code mode package configuration: llmModel must be provider/modelId.");
+			merged = {
+				...merged,
+				...entry.config
+			};
+		}
+		return merged;
+	}
+};
+//#endregion
+//#region src/services/llmNamespace/index.ts
+const MAX_INPUT_BYTES = 65536;
+const MAX_SCHEMA_BYTES = 16384;
+const MAX_OUTPUT_BYTES = 65536;
+const MAX_CALLS = 8;
+const MAX_CONCURRENT = 2;
+const DEFAULT_TOKENS = 1024;
+const MAX_TOKENS = 4096;
+const RESULT_TOOL = "return_result";
+const MODEL = /^[^/\s]+\/\S+$/u;
+const META = Meta["http://json-schema.org/draft-07/schema#"];
+const DECLARATIONS$1 = `interface LlmRequest {
+  prompt: string;
+  /** Explicit JSON input only, never the surrounding conversation. */
+  input?: unknown;
+  system?: string;
+  /** provider/modelId; overrides llmModel config and the live session model. */
+  model?: string;
+  /** Defaults to 1024, maximum 4096. */
+  maxTokens?: number;
+}
+declare const llm: {
+  /** One-shot text transform. At most 8 calls per exec, 2 concurrently. */
+  complete(request: LlmRequest): Promise<{ text: string; model: string }>;
+  /** Object-root JSON Schema (draft 7), local nonrecursive refs only. Invalid output rejects without retry. */
+  json(request: LlmRequest & { schema: Record<string, unknown> }): Promise<{ value: unknown; model: string }>;
+};`;
+function jsonText(value, limit, label) {
+	const json = JSON.stringify(value, (_key, item) => {
+		if (item === void 0 || typeof item === "function" || typeof item === "symbol" || typeof item === "bigint" || typeof item === "number" && !Number.isFinite(item)) throw new TypeError(`${label} must be JSON serializable.`);
+		return item;
+	});
+	if (json === void 0) throw new TypeError(`${label} must be JSON serializable.`);
+	if (new TextEncoder().encode(json).length > limit) throw new RangeError(`${label} exceeds ${limit} bytes.`);
+	return json;
+}
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Reject unsupported references and recursive schemas before spending tokens or entering the validator. */
+function checkedSchema(value) {
+	const schema = JSON.parse(jsonText(value, MAX_SCHEMA_BYTES, "LLM schema"));
+	if (!object(schema) || schema.type !== "object") throw new TypeError("LLM schema must have type: object.");
+	if (schema.$schema !== void 0 && schema.$schema !== "http://json-schema.org/draft-07/schema#") throw new TypeError("LLM schema supports JSON Schema draft 7 only.");
+	if (!Check$1(META, schema)) throw new TypeError("Invalid LLM JSON Schema.");
+	let expanded = 0;
+	const visit = (node, ancestors) => {
+		if (!object(node)) return;
+		if (++expanded > 1024) throw new TypeError("LLM schema exceeds 1024 expanded schema nodes.");
+		if (ancestors.length > 32 || ancestors.includes(node)) throw new TypeError("LLM schema references must be nonrecursive and at most 32 levels deep.");
+		const stack = [...ancestors, node];
+		if (node.$dynamicRef !== void 0 || node.$recursiveRef !== void 0 || node.$id !== void 0) throw new TypeError("LLM schema supports local $ref only, without $id.");
+		if (node.$ref !== void 0) {
+			if (typeof node.$ref !== "string" || !node.$ref.startsWith("#/")) throw new TypeError("LLM schema supports local JSON-pointer $ref only.");
+			let resolved = schema;
+			for (const segment of node.$ref.slice(2).split("/")) {
+				const key = segment.replace(/~1/gu, "/").replace(/~0/gu, "~");
+				resolved = resolved !== null && typeof resolved === "object" && Object.hasOwn(resolved, key) ? Reflect.get(resolved, key) : void 0;
+			}
+			if (!object(resolved) && typeof resolved !== "boolean") throw new TypeError("Unresolved LLM schema $ref.");
+			visit(resolved, stack);
+		}
+		for (const key of [
+			"properties",
+			"patternProperties",
+			"definitions",
+			"$defs",
+			"dependencies"
+		]) if (object(node[key])) for (const child of Object.values(node[key])) visit(child, stack);
+		for (const key of [
+			"items",
+			"additionalItems",
+			"additionalProperties",
+			"contains",
+			"propertyNames",
+			"not",
+			"if",
+			"then",
+			"else",
+			"allOf",
+			"anyOf",
+			"oneOf"
+		]) {
+			const child = node[key];
+			if (Array.isArray(child)) for (const item of child) visit(item, stack);
+			else visit(child, stack);
+		}
+	};
+	visit(schema, []);
+	return schema;
+}
+function request$1(value, structured) {
+	if (!object(value)) throw new TypeError("LLM request must be an object.");
+	const allowed = [
+		"prompt",
+		"input",
+		"system",
+		"model",
+		"maxTokens",
+		...structured ? ["schema"] : []
+	];
+	if (Object.keys(value).some((key) => !allowed.includes(key))) throw new TypeError("Unknown LLM request field.");
+	if (typeof value.prompt !== "string" || !value.prompt.trim()) throw new TypeError("LLM prompt must be nonempty text.");
+	if (value.system !== void 0 && typeof value.system !== "string") throw new TypeError("LLM system must be text.");
+	if (value.model !== void 0 && (typeof value.model !== "string" || !MODEL.test(value.model) || value.model.length > 256)) throw new TypeError("LLM model must be provider/modelId.");
+	if (value.maxTokens !== void 0 && (!Number.isInteger(value.maxTokens) || Number(value.maxTokens) < 1 || Number(value.maxTokens) > MAX_TOKENS)) throw new RangeError(`LLM maxTokens must be an integer from 1 to ${MAX_TOKENS}.`);
+	return {
+		prompt: value.prompt,
+		...value.input === void 0 ? {} : { input: value.input },
+		...value.system === void 0 ? {} : { system: value.system },
+		...value.model === void 0 ? {} : { model: value.model },
+		...value.maxTokens === void 0 ? {} : { maxTokens: value.maxTokens },
+		...structured ? { schema: checkedSchema(value.schema) } : {}
+	};
+}
+/** Explicit data transforms over the host's guarded completions, never a tool-using agent. */
+function createLlmNamespace(options) {
+	const { context } = options;
+	return {
+		name: "llm",
+		summary: "One-shot LLM text and schema-validated JSON transforms. Explicit input only, bounded calls, no tools or retries.",
+		declarations: DECLARATIONS$1,
+		portable: true,
+		bind(run) {
+			if (run.sessionId !== context.sessionId) throw new Error("LLM namespace belongs to another session.");
+			let disposed = false;
+			let calls = 0;
+			let active = 0;
+			run.onDispose(() => {
+				disposed = true;
+			});
+			const available = () => {
+				run.signal.throwIfAborted();
+				if (disposed) throw new Error("LLM namespace run is disposed.");
+			};
+			const call = async (input, structured) => {
+				available();
+				if (calls >= MAX_CALLS) throw new RangeError(`At most ${MAX_CALLS} LLM calls per exec.`);
+				if (active >= MAX_CONCURRENT) throw new RangeError(`At most ${MAX_CONCURRENT} concurrent LLM calls per exec.`);
+				const params = request$1(input, structured);
+				const userInput = params.input === void 0 ? params.prompt : `${params.prompt}\n\nInput (JSON):\n${jsonText(params.input, MAX_INPUT_BYTES, "LLM input")}`;
+				const systemPrompt = `${params.system ?? "Transform only the explicit input according to the request."}${structured ? "\nCall return_result exactly once with the result. Do not call other tools." : ""}`;
+				if (new TextEncoder().encode(systemPrompt + userInput).length > MAX_INPUT_BYTES) throw new RangeError("LLM prompt and input exceed 65536 bytes.");
+				active += 1;
+				const started = Date.now();
+				let model;
+				let tokens;
+				const record = (ok, error) => run.record?.({
+					name: structured ? "llm.json" : "llm.complete",
+					tool: "llm",
+					args: {
+						...model ? { model } : {},
+						maxTokens: params.maxTokens ?? DEFAULT_TOKENS
+					},
+					ok,
+					ms: Date.now() - started,
+					...error === void 0 ? {} : { error },
+					...tokens === void 0 ? {} : { result: {
+						content: [],
+						details: { totalTokens: tokens }
+					} }
+				});
+				try {
+					const config = await options.config();
+					const current = params.model || config.llmModel ? void 0 : (await context.session.readModelSettings?.())?.model ?? context.model;
+					model = params.model ?? config.llmModel ?? (current ? `${current.provider}/${current.id}` : void 0);
+					available();
+					if (!model || !context.textCompletion?.available(model)) throw new Error(`LLM model is unavailable${model ? `: ${model}` : ""}.`);
+					if (structured ? !context.toolCompletion : !context.textCompletion) throw new Error("LLM completion is unavailable on this host.");
+					if (calls >= MAX_CALLS) throw new RangeError(`At most ${MAX_CALLS} LLM calls per exec.`);
+					calls += 1;
+					const completion = {
+						systemPrompt,
+						input: userInput,
+						maxTokens: params.maxTokens ?? DEFAULT_TOKENS,
+						signal: run.signal,
+						recordUsage: true
+					};
+					if (!structured) {
+						const text = await context.textCompletion.complete(model, completion);
+						available();
+						jsonText(text, MAX_OUTPUT_BYTES, "LLM output");
+						record(true);
+						return {
+							text,
+							model
+						};
+					}
+					const schema = params.schema;
+					const response = await context.toolCompletion.complete(model, {
+						...completion,
+						tools: [{
+							name: RESULT_TOOL,
+							description: "Return the requested structured result.",
+							parameters: schema
+						}]
+					});
+					tokens = response.usage.totalTokens;
+					available();
+					if (response.toolCalls.length !== 1 || response.toolCalls[0]?.name !== RESULT_TOOL) throw new Error("LLM must return exactly one return_result call.");
+					const value = JSON.parse(jsonText(response.toolCalls[0].arguments, MAX_OUTPUT_BYTES, "LLM output"));
+					if (!Check$1(schema, value)) {
+						const [, errors] = Errors(schema, value);
+						throw new TypeError(`LLM result failed schema validation: ${errors[0]?.message ?? "invalid result"}`);
+					}
+					record(true);
+					return {
+						value,
+						model
+					};
+				} catch (error) {
+					record(false, error instanceof Error ? error.message : String(error));
+					throw error;
+				} finally {
+					active -= 1;
+				}
+			};
+			return {
+				complete: (input) => call(input, false),
+				json: (input) => call(input, true)
+			};
+		}
+	};
+}
+//#endregion
+//#region src/services/shellNamespace/index.ts
+const DEFAULT_TIMEOUT_MS = 1e4;
+const MAX_TIMEOUT_MS = 12e4;
+const MAX_COMMAND_CHARS = 65536;
+const MAX_OUTPUT_CHARS = 32768;
+const TRUNCATED = "\n[truncated]";
+const DECLARATIONS = `declare const shell: {
+  /** Short foreground Bash command in the session cwd/environment. Nonzero exits are returned; cancellation and timeout reject. */
+  bash(input: { command: string; timeoutMs?: number }): Promise<{ stdout: string; stderr: string; exitCode: number }>;
+};`;
+function request(input) {
+	if (input === null || typeof input !== "object" || Array.isArray(input)) throw new TypeError("shell.bash expects an object.");
+	const value = input;
+	if (Object.keys(value).some((key) => key !== "command" && key !== "timeoutMs")) throw new TypeError("shell.bash accepts only command and timeoutMs.");
+	if (typeof value.command !== "string" || !value.command.trim() || value.command.length > MAX_COMMAND_CHARS) throw new TypeError(`shell.bash command must be nonempty text of at most ${MAX_COMMAND_CHARS} characters.`);
+	if (value.timeoutMs !== void 0 && (!Number.isInteger(value.timeoutMs) || Number(value.timeoutMs) < 1 || Number(value.timeoutMs) > MAX_TIMEOUT_MS)) throw new RangeError(`shell.bash timeoutMs must be an integer from 1 to ${MAX_TIMEOUT_MS}.`);
+	return {
+		command: value.command,
+		timeoutMs: value.timeoutMs
+	};
+}
+/** Deadline-bound commands for post-processing, separate from Runner's supervised processes. */
+function createShellNamespace(options) {
+	return {
+		name: "shell",
+		summary: "Run short foreground Bash commands with bounded stdout/stderr and a deadline. No background or interactive mode.",
+		declarations: DECLARATIONS,
+		portable: true,
+		bind(run) {
+			if (run.sessionId !== options.context.sessionId) throw new Error("Shell namespace belongs to another session.");
+			const disposal = new AbortController();
+			const lifetime = AbortSignal.any([run.signal, disposal.signal]);
+			run.onDispose(() => disposal.abort(/* @__PURE__ */ new Error("Shell namespace run is disposed.")));
+			return { async bash(input) {
+				lifetime.throwIfAborted();
+				const params = request(input);
+				const shell = options.shell();
+				if (!shell) throw new Error("Shell commands are not available on this host.");
+				const timeoutMs = params.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+				const signal = AbortSignal.any([lifetime, AbortSignal.timeout(timeoutMs)]);
+				const output = {
+					stdout: "",
+					stderr: ""
+				};
+				const truncated = {
+					stdout: false,
+					stderr: false
+				};
+				const started = Date.now();
+				let ok = false;
+				let failure;
+				try {
+					const result = await shell.exec(params.command, {
+						cwd: options.context.cwd,
+						env: Object.fromEntries(Object.entries(options.context.environment).filter((entry) => entry[1] !== void 0)),
+						inheritEnv: false,
+						onOutput: (text, _context, { stream }) => {
+							const remaining = MAX_OUTPUT_CHARS - output[stream].length;
+							output[stream] += text.slice(0, remaining);
+							if (text.length > remaining) truncated[stream] = true;
+						}
+					}, withAbortSignal(signal, BACKGROUND_CONTEXT));
+					signal.throwIfAborted();
+					const { exitCode } = getOrThrow(result);
+					ok = exitCode === 0;
+					return {
+						stdout: output.stdout + (truncated.stdout ? TRUNCATED : ""),
+						stderr: output.stderr + (truncated.stderr ? TRUNCATED : ""),
+						exitCode
+					};
+				} catch (error) {
+					failure = error instanceof Error ? error.message : String(error);
+					throw error;
+				} finally {
+					run.record?.({
+						name: "shell.bash",
+						tool: "shell",
+						args: { timeoutMs },
+						ok,
+						ms: Date.now() - started,
+						...failure === void 0 ? {} : { error: failure }
+					});
+				}
+			} };
+		}
+	};
+}
+//#endregion
 //#region src/extensions/workspaces/sessions/(backend)/_lib/root.server.ts
 /** One registry per session: contributors register into it, `discover` and `exec` read it. */
-function createCodemodeSession({ context }) {
+function createCodemodeSession({ context, agent, host }) {
 	const registry = createCodemodeRegistry();
 	context.inject([PO_SERVER_SCOPE_SERVICE], (scoped) => requirePoServerScope(scoped).provide(PO_CODEMODE_CONTRACT, registry));
 	let temporaryDirectory;
@@ -130,14 +502,46 @@ function createCodemodeSession({ context }) {
 		fs: () => readPoFs(context),
 		temporaryDirectory: () => temporaryDirectory
 	});
-	return { value: {
-		registry,
-		...createCodemodeTools({
+	const execution = agent?.context;
+	const config = execution ? new LlmConfigService({
+		fs: () => readPoFs(context),
+		environment: execution.environment,
+		homeDirectory: host.context.homeDirectory
+	}) : void 0;
+	let disposeNamespaces;
+	if (execution && config) {
+		context.inject([PO_CONFIG_SERVICE], (scoped) => {
+			const service = scoped.get(PO_CONFIG_SERVICE);
+			return service ? config.bind(() => service.getSnapshot()) : void 0;
+		});
+		const registration = registry.register("@agimon-ai/po-codemode", createLlmNamespace({
+			context: execution,
+			config: () => config.current()
+		}));
+		const shellRegistration = registry.register("@agimon-ai/po-codemode", createShellNamespace({
+			context: execution,
+			shell: () => context.get(PO_SHELL_SERVICE)
+		}));
+		disposeNamespaces = () => {
+			registration.dispose();
+			shellRegistration.dispose();
+		};
+	}
+	return {
+		value: {
 			registry,
-			isolate: () => readPoIsolate(context),
-			scripts
-		})
-	} };
+			...createCodemodeTools({
+				registry,
+				isolate: () => readPoIsolate(context),
+				npm: () => readPoNpm(context),
+				scripts
+			})
+		},
+		services: [(scoped) => {
+			if (config) scoped.provide(PO_CODEMODE_LLM_CONFIG_SERVICE, config);
+		}],
+		onDispose: () => disposeNamespaces?.()
+	};
 }
 const root = defineRoot(createCodemodeSession);
 //#endregion
@@ -147,14 +551,34 @@ var root_server_default = defineRoot(root);
 //#region src/extensions/workspaces/sessions/(backend)/contract/codemode.server.ts
 var codemode_server_default = defineServiceContract(PO_CODEMODE_SERVICE, { scope: "session" });
 //#endregion
-//#region src/extensions/workspaces/sessions/(backend)/resource/po-use-codemode.server.ts
-var po_use_codemode_server_default = defineResource({
-	name: "po-use-codemode",
+//#region src/extensions/workspaces/sessions/(backend)/resource/codemode-how-to-llm.server.ts
+var codemode_how_to_llm_server_default = defineResource({
+	name: "codemode-how-to-llm",
+	description: "Use the llm namespace for one-shot text and schema-checked JSON transformations inside exec.",
+	pinned: true,
+	kind: "skill",
+	path: packageResourcePath(import.meta.url, "src/prompts/codemode-how-to-llm/SKILL.md"),
+	read: () => readPackageResource(import.meta.url, "src/prompts/codemode-how-to-llm/SKILL.md")
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/codemode-how-to-shell.server.ts
+var codemode_how_to_shell_server_default = defineResource({
+	name: "codemode-how-to-shell",
+	description: "Use shell.bash for short deadline-bound Bash commands and code-side output post-processing.",
+	pinned: true,
+	kind: "skill",
+	path: packageResourcePath(import.meta.url, "src/prompts/codemode-how-to-shell/SKILL.md"),
+	read: () => readPackageResource(import.meta.url, "src/prompts/codemode-how-to-shell/SKILL.md")
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/how-to-codemode.server.ts
+var how_to_codemode_server_default = defineResource({
+	name: "how-to-codemode",
 	description: "Use @agimon-ai/po-codemode: Code mode for Po sessions: discover and exec over namespaces other packages contribute",
-	when: PO_HELP_WHEN,
+	pinned: true,
 	kind: "skill",
-	path: packageResourcePath(import.meta.url, "src/prompts/po-use-codemode/SKILL.md"),
-	read: () => readPackageResource(import.meta.url, "src/prompts/po-use-codemode/SKILL.md")
+	path: packageResourcePath(import.meta.url, "src/prompts/how-to-codemode/SKILL.md"),
+	read: () => readPackageResource(import.meta.url, "src/prompts/how-to-codemode/SKILL.md")
 });
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/tool/discover.server.ts
@@ -183,7 +607,11 @@ const serverPlugin = defineServerPlugin({
 		return {
 			...composeRootHooks(scopeSession),
 			get resources() {
-				return [at(po_use_codemode_server_default, contextSession)];
+				return [
+					at(codemode_how_to_llm_server_default, contextSession),
+					at(codemode_how_to_shell_server_default, contextSession),
+					at(how_to_codemode_server_default, contextSession)
+				];
 			},
 			get tools() {
 				return [via({ name: "discover" }, at(discover_server_default, contextSession)), via({ name: "exec" }, at(exec_server_default, contextSession))];