@code-yeongyu/senpi 2026.7.11 → 2026.7.13

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/output-bridge.ts

@@ -0,0 +1,96 @@
+import type { AgentToolResult } from "@code-yeongyu/senpi";
+import { type Static, Type } from "typebox";
+import { Check, Errors } from "typebox/value";
+import type { ExecuteTool } from "../tool/types.ts";
+
+const outputArgsSchema = Type.Object(
+	{
+		ids: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+		format: Type.Optional(Type.Union([Type.Literal("raw"), Type.Literal("tail")])),
+		offset: Type.Optional(Type.Integer({ minimum: 1 })),
+		limit: Type.Optional(Type.Integer({ minimum: 1 })),
+	},
+	{ additionalProperties: false },
+);
+
+type OutputArgs = Static<typeof outputArgsSchema>;
+
+export type OutputExecuteTool = ExecuteTool & {
+	readonly isToolAvailable?: (name: string) => boolean;
+};
+
+export type MarshalledToolResult = {
+	readonly text: string;
+};
+
+export interface RunEvalOutputOptions {
+	readonly taskOutputToolName: string;
+	readonly executeTool: OutputExecuteTool;
+	readonly signal?: AbortSignal;
+	readonly marshalToolResult: (result: AgentToolResult<unknown>) => MarshalledToolResult;
+}
+
+class OutputArgumentsError extends Error {
+	readonly name = "OutputArgumentsError";
+
+	constructor(summary: string) {
+		super(`output() received invalid arguments: ${summary}`);
+	}
+}
+
+class OutputUnavailableError extends Error {
+	readonly name = "OutputUnavailableError";
+
+	constructor(toolName: string) {
+		super(`output() unavailable: no "${toolName}" tool is registered in this session`);
+	}
+}
+
+export async function runEvalOutput(args: unknown, options: RunEvalOutputOptions): Promise<string | readonly string[]> {
+	const parsed = parseOutputArgs(args);
+	if (options.executeTool.isToolAvailable?.(options.taskOutputToolName) === false) {
+		throw new OutputUnavailableError(options.taskOutputToolName);
+	}
+
+	const mode = parsed.format === "tail" ? "tail" : "full";
+	const transcripts = await Promise.all(
+		parsed.ids.map(async (id) => {
+			let result: AgentToolResult<unknown>;
+			try {
+				result = await options.executeTool(
+					options.taskOutputToolName,
+					{
+						...(id.startsWith("st_") ? { task_id: id } : { name: id }),
+						mode,
+						block: true,
+					},
+					options.signal === undefined ? undefined : { signal: options.signal },
+				);
+			} catch (error) {
+				if (isUnavailableToolError(error)) throw new OutputUnavailableError(options.taskOutputToolName);
+				throw error;
+			}
+
+			// ADAPTATION: task_output owns transcripts, so no AgentOutputManager cache or
+			// oh-my-pi query/json/stripped formats exist on this bridge.
+			const transcript = options.marshalToolResult(result).text;
+			const lines = transcript.split(/\r?\n/u);
+			const start = (parsed.offset ?? 1) - 1;
+			return lines.slice(start, parsed.limit === undefined ? undefined : start + parsed.limit).join("\n");
+		}),
+	);
+	return transcripts.length === 1 ? transcripts[0] : transcripts;
+}
+
+function parseOutputArgs(value: unknown): OutputArgs {
+	if (Check(outputArgsSchema, value)) return value;
+	const summary = Errors(outputArgsSchema, value)
+		.map((error) => `${error.instancePath || "/"} ${error.message}`)
+		.join("; ");
+	throw new OutputArgumentsError(summary || "invalid value");
+}
+
+function isUnavailableToolError(error: unknown): boolean {
+	if (typeof error !== "object" || error === null || Array.isArray(error)) return false;
+	return "code" in error && (error.code === "unknown_tool" || error.code === "inactive_tool");
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/bridges/schema-injection.ts

@@ -0,0 +1,3 @@
+export function injectSchemaInstruction(prompt: string, schema: unknown): string {
+	return `${prompt}\n\nRespond ONLY with JSON matching this JSON-Schema:\n${JSON.stringify(schema)}`;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/completion/handler.ts

@@ -1,6 +1,7 @@
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { Api, AssistantMessage, Context, Model, SimpleStreamOptions } from "@earendil-works/pi-ai/compat";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
+import { injectSchemaInstruction } from "../bridges/schema-injection.ts";
 
 export interface CompletionRequest {
 	readonly prompt: string;
@@ -20,19 +21,27 @@ export type CompleteSimple = (
 	options?: SimpleStreamOptions,
 ) => Promise<AssistantMessage>;
 
-interface CompletionDetails {
+type CompletionDetails = {
 	readonly model: string;
 	readonly structured: boolean;
+};
+
+type CompletionTier = "smol" | "default" | "slow";
+
+class CompletionUnknownTierError extends Error {
+	readonly name = "CompletionUnknownTierError";
+
+	constructor(tier: string) {
+		super(`completion() could not resolve the "${tier}" model tier; expected "smol", "default", or "slow".`);
+	}
 }
 
-interface ResolvedAuth {
-	readonly ok: boolean;
-	readonly apiKey?: string;
-	readonly headers?: Record<string, string>;
-	readonly env?: Record<string, string>;
-	readonly extraBody?: Record<string, unknown>;
-	readonly upstreamModelId?: string;
-	readonly error?: string;
+class CompletionTierUnavailableError extends Error {
+	readonly name = "CompletionTierUnavailableError";
+
+	constructor(tier: Exclude<CompletionTier, "default">) {
+		super(`completion() could not resolve the "${tier}" model tier: no configured models are available.`);
+	}
 }
 
 export function createCompletionHandler(
@@ -46,16 +55,20 @@ async function runCompletion(
 	request: CompletionRequest,
 	complete: CompleteSimple,
 ): Promise<CompletionResult> {
-	const model = resolveRequestedModel(ctx.model, request.model);
-	if (!model) throw noModelCredentialsError();
-	const auth = (await ctx.modelRegistry.getApiKeyAndHeaders(model)) as ResolvedAuth;
-	if (!auth.ok || !auth.apiKey) throw noModelCredentialsError(auth.error);
+	const tier = resolveCompletionTier(request.model);
+	const model = resolveRequestedModel(ctx, tier);
+	if (!model) throw unavailableModelError(tier);
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+	if (!auth.ok) throw noModelCredentialsError(auth.error);
+	if (!auth.apiKey) throw noModelCredentialsError();
 	const requestModel = auth.upstreamModelId ? { ...model, id: auth.upstreamModelId } : model;
+	const structured = request.schema !== undefined;
+	const prompt = structured ? injectSchemaInstruction(request.prompt, request.schema) : request.prompt;
 	const message = await complete(
 		requestModel,
 		{
 			systemPrompt: request.system ?? "You are a helpful assistant.",
-			messages: [{ role: "user", content: [{ type: "text", text: request.prompt }], timestamp: Date.now() }],
+			messages: [{ role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() }],
 		},
 		{
 			apiKey: auth.apiKey,
@@ -65,7 +78,7 @@ async function runCompletion(
 			signal: ctx.signal,
 		},
 	);
-	return formatCompletion(message, model, request.schema !== undefined);
+	return formatCompletion(message, model, structured);
 }
 
 function normalizeRequest(request: CompletionRequest): CompletionRequest {
@@ -78,25 +91,77 @@ function normalizeRequest(request: CompletionRequest): CompletionRequest {
 	};
 }
 
-function resolveRequestedModel(current: Model<Api> | undefined, requested: string | undefined): Model<Api> | undefined {
-	if (requested === undefined || requested === "default") return current;
-	if (requested === "smol" || requested === "slow") {
-		throw new Error('completion() model roles are not supported; use model: "default" or omit model.');
+function resolveCompletionTier(requested: string | undefined): CompletionTier {
+	switch (requested) {
+		case undefined:
+		case "default":
+			return "default";
+		case "smol":
+			return "smol";
+		case "slow":
+			return "slow";
+		default:
+			throw new CompletionUnknownTierError(requested);
+	}
+}
+
+function resolveRequestedModel(ctx: ExtensionContext, tier: CompletionTier): Model<Api> | undefined {
+	switch (tier) {
+		case "default":
+			return ctx.model;
+		case "smol":
+			return lowestCostModel(ctx.modelRegistry.getAvailable());
+		case "slow":
+			return highestCostModel(ctx.modelRegistry.getAvailable());
+		default:
+			return assertNever(tier);
+	}
+}
+
+function unavailableModelError(tier: CompletionTier): Error {
+	switch (tier) {
+		case "default":
+			return noModelCredentialsError();
+		case "smol":
+		case "slow":
+			return new CompletionTierUnavailableError(tier);
+		default:
+			return assertNever(tier);
+	}
+}
+
+function lowestCostModel(models: readonly Model<Api>[]): Model<Api> | undefined {
+	let selected: Model<Api> | undefined;
+	for (const model of models) {
+		if (selected === undefined || promptAndResponseCost(model) < promptAndResponseCost(selected)) selected = model;
 	}
-	if (!current) return undefined;
-	if (requested === current.id || requested === `${current.provider}/${current.id}`) return current;
-	throw new Error(`completion() could not resolve requested model "${requested}" from the current session model.`);
+	return selected;
+}
+
+function highestCostModel(models: readonly Model<Api>[]): Model<Api> | undefined {
+	let selected: Model<Api> | undefined;
+	for (const model of models) {
+		if (selected === undefined || promptAndResponseCost(model) > promptAndResponseCost(selected)) selected = model;
+	}
+	return selected;
+}
+
+function promptAndResponseCost(model: Model<Api>): number {
+	return model.cost.input + model.cost.output;
 }
 
 function formatCompletion(message: AssistantMessage, model: Model<Api>, structured: boolean): CompletionResult {
 	if (message.stopReason === "error") throw new Error(message.errorMessage ?? "completion() request failed.");
 	if (message.stopReason === "aborted") throw new Error("completion() request aborted.");
 	const text = extractText(message);
-	if (!structured) return { text, details: { model: formatModel(model), structured: false } };
+	const details = { model: formatModel(model), structured };
+	if (!structured) return { text, details };
 	try {
-		return { value: JSON.parse(text) as unknown, details: { model: formatModel(model), structured: true } };
-	} catch {
-		throw new Error("completion() did not return a structured JSON response.");
+		const value: unknown = JSON.parse(text);
+		return { value, details };
+	} catch (error) {
+		if (error instanceof SyntaxError) return { value: { parseError: error.message }, details };
+		throw error;
 	}
 }
 
@@ -121,3 +186,7 @@ function formatModel(model: Model<Api>): string {
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
 }
+
+function assertNever(value: never): never {
+	throw new CompletionUnknownTierError(String(value));
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/completion/tool-bridge.ts

@@ -15,9 +15,14 @@ export type CompletionToolCallSummary = { readonly ok: true } | { readonly ok: f
 
 export async function handleCompletionToolCall(options: CompletionToolCallOptions): Promise<CompletionToolCallSummary> {
 	try {
-		const value = await options.complete(toCompletionRequest(options.message.args), options.ctx);
+		const result = await options.complete(toCompletionRequest(options.message.args), options.ctx);
 		if (!options.isActive()) return { ok: false, error: "completion() result ignored after eval finalization" };
-		options.kernel.deliverToolReply({ type: "tool-reply", callId: options.message.callId, ok: true, value });
+		options.kernel.deliverToolReply({
+			type: "tool-reply",
+			callId: options.message.callId,
+			ok: true,
+			value: completionReplyValue(result),
+		});
 		return { ok: true };
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
@@ -44,3 +49,7 @@ function toCompletionRequest(value: unknown): CompletionRequest {
 	}
 	throw new Error("completion() received invalid arguments");
 }
+
+function completionReplyValue(result: CompletionResult): unknown {
+	return "value" in result ? result.value : result.text;
+}

package/node_modules/@code-yeongyu/senpi-codemode/src/config/settings.ts

@@ -20,12 +20,41 @@ export const codemodeSettingsSchema = Type.Object(
 		),
 		cellTimeoutSeconds: Type.Optional(Type.Number({ minimum: 1 })),
 		parallelPoolWidth: Type.Optional(Type.Number({ minimum: 1 })),
+		taskTools: Type.Optional(
+			Type.Object(
+				{
+					task: Type.Optional(Type.String()),
+					output: Type.Optional(Type.String()),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		outputSink: Type.Optional(
+			Type.Object(
+				{
+					headBytes: Type.Optional(Type.Number({ minimum: 0 })),
+					maxColumns: Type.Optional(Type.Number({ minimum: 0 })),
+				},
+				{ additionalProperties: false },
+			),
+		),
+		statusEvents: Type.Optional(Type.Boolean()),
 	},
 	{ additionalProperties: false },
 );
 
 export type CodemodeSettingsInput = Static<typeof codemodeSettingsSchema>;
 
+export interface CodemodeTaskTools {
+	readonly task: string;
+	readonly output: string;
+}
+
+export interface CodemodeOutputSink {
+	readonly headBytes: number;
+	readonly maxColumns: number;
+}
+
 export interface CodemodeSettings {
 	readonly languages: {
 		readonly py: boolean;
@@ -35,22 +64,31 @@ export interface CodemodeSettings {
 	};
 	readonly cellTimeoutSeconds: number;
 	readonly parallelPoolWidth: number;
+	readonly taskTools?: CodemodeTaskTools;
+	readonly outputSink?: CodemodeOutputSink;
+	readonly statusEvents?: boolean;
 }
 
+export type ResolvedCodemodeSettings = CodemodeSettings & {
+	readonly taskTools: CodemodeTaskTools;
+	readonly outputSink: CodemodeOutputSink;
+	readonly statusEvents: boolean;
+};
+
 export interface LoadCodemodeSettingsOptions {
 	readonly cwd?: string;
 	readonly homeDir?: string;
 }
 
 export interface LoadedCodemodeSettings {
-	readonly settings: CodemodeSettings;
+	readonly settings: ResolvedCodemodeSettings;
 	readonly source: string | null;
 	readonly warnings: readonly string[];
 }
 
 // OMP settings-schema.ts:3211-3299 has language/path settings only; eval.ts:427
 // defaults timeout to 30s, and codemode pins concurrency-bridge.ts:30 width to 4.
-export const defaultCodemodeSettings: CodemodeSettings = {
+export const defaultCodemodeSettings: ResolvedCodemodeSettings = {
 	languages: {
 		py: true,
 		js: true,
@@ -59,8 +97,26 @@ export const defaultCodemodeSettings: CodemodeSettings = {
 	},
 	cellTimeoutSeconds: 30,
 	parallelPoolWidth: 4,
+	taskTools: {
+		task: "task",
+		output: "task_output",
+	},
+	outputSink: {
+		headBytes: 20_480,
+		maxColumns: 768,
+	},
+	statusEvents: true,
 };
 
+const languageEnvironmentFlags = {
+	py: "SENPI_CODEMODE_PY",
+	js: "SENPI_CODEMODE_JS",
+	rb: "SENPI_CODEMODE_RB",
+	jl: "SENPI_CODEMODE_JL",
+} as const;
+
+type Environment = Readonly<Record<string, string | undefined>>;
+
 export async function loadCodemodeSettings(options: LoadCodemodeSettingsOptions = {}): Promise<LoadedCodemodeSettings> {
 	const cwd = options.cwd ?? process.cwd();
 	const homeDir = options.homeDir ?? homedir();
@@ -76,16 +132,29 @@ export async function loadCodemodeSettings(options: LoadCodemodeSettingsOptions
 	return { settings: defaultCodemodeSettings, source: null, warnings: [] };
 }
 
+export function resolveEnabledLanguages(
+	settings: CodemodeSettings,
+	env: Environment = process.env,
+): CodemodeSettings["languages"] {
+	return {
+		py: resolveLanguage(settings.languages.py, env[languageEnvironmentFlags.py]),
+		js: resolveLanguage(settings.languages.js, env[languageEnvironmentFlags.js]),
+		rb: resolveLanguage(settings.languages.rb, env[languageEnvironmentFlags.rb]),
+		jl: resolveLanguage(settings.languages.jl, env[languageEnvironmentFlags.jl]),
+	};
+}
+
 async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
 	const raw = await readFile(path, "utf8");
 	let parsed: unknown;
 	try {
 		parsed = JSON.parse(raw);
 	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
 		return {
 			settings: defaultCodemodeSettings,
 			source: path,
-			warnings: [`Invalid JSON in ${path}: ${errorMessage(error)}. Falling back to codemode defaults.`],
+			warnings: [`Invalid JSON in ${path}: ${message}. Falling back to codemode defaults.`],
 		};
 	}
 
@@ -100,7 +169,7 @@ async function loadSettingsFile(path: string): Promise<LoadedCodemodeSettings> {
 	return { settings: mergeSettings(parsed), source: path, warnings: [] };
 }
 
-function mergeSettings(input: CodemodeSettingsInput): CodemodeSettings {
+function mergeSettings(input: CodemodeSettingsInput): ResolvedCodemodeSettings {
 	return {
 		languages: {
 			py: input.languages?.py ?? defaultCodemodeSettings.languages.py,
@@ -110,9 +179,32 @@ function mergeSettings(input: CodemodeSettingsInput): CodemodeSettings {
 		},
 		cellTimeoutSeconds: input.cellTimeoutSeconds ?? defaultCodemodeSettings.cellTimeoutSeconds,
 		parallelPoolWidth: input.parallelPoolWidth ?? defaultCodemodeSettings.parallelPoolWidth,
+		taskTools: {
+			task: input.taskTools?.task ?? defaultCodemodeSettings.taskTools.task,
+			output: input.taskTools?.output ?? defaultCodemodeSettings.taskTools.output,
+		},
+		outputSink: {
+			headBytes: input.outputSink?.headBytes ?? defaultCodemodeSettings.outputSink.headBytes,
+			maxColumns: input.outputSink?.maxColumns ?? defaultCodemodeSettings.outputSink.maxColumns,
+		},
+		statusEvents: input.statusEvents ?? defaultCodemodeSettings.statusEvents,
 	};
 }
 
+function resolveLanguage(fileSetting: boolean, environmentValue: string | undefined): boolean {
+	if (environmentValue === undefined) return fileSetting;
+	switch (environmentValue.trim().toLowerCase()) {
+		case "0":
+		case "false":
+			return false;
+		case "1":
+		case "true":
+			return true;
+		default:
+			return fileSetting;
+	}
+}
+
 async function fileExists(path: string): Promise<boolean> {
 	try {
 		await access(path);
@@ -121,7 +213,3 @@ async function fileExists(path: string): Promise<boolean> {
 		return false;
 	}
 }
-
-function errorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}

package/node_modules/@code-yeongyu/senpi-codemode/src/extension/session-manager.ts

@@ -1,3 +1,4 @@
+import { join } from "node:path";
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import { type BridgeServerHandle, startBridgeServer } from "../bridge/http-server.ts";
 import type { KernelToHostMessage } from "../bridge/protocol.ts";
@@ -16,11 +17,20 @@ export interface CodemodeSessionManager extends EvalKernelManager {
 	setContext?(ctx: ExtensionContext): void;
 }
 
+export interface EvalExecutionTracker {
+	assertEvalExecutionAllowed(): void;
+	trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result>;
+}
+
 export interface CreateCodemodeSessionManagerOptions {
 	readonly sessionId: string;
 	readonly cwd: string;
 	readonly settings: CodemodeSettings;
 	readonly availability: InterpreterAvailability;
+	/** Session-scoped roots exposed to kernel helpers such as local://. */
+	readonly localRoots?: Readonly<Record<string, string>>;
+	/** Session-adjacent directory used for persisted eval artifacts. */
+	readonly artifactsDir?: string;
 	readonly executeTool: ExecuteTool;
 	readonly complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
@@ -33,7 +43,7 @@ export async function createCodemodeSessionManager(
 	return manager;
 }
 
-class CodemodeSessionDisposedError extends Error {
+export class CodemodeSessionDisposedError extends Error {
 	readonly name = "CodemodeSessionDisposedError";
 
 	constructor() {
@@ -148,17 +158,28 @@ class DefaultCodemodeSessionManager implements CodemodeSessionManager {
 	async #createKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
 		const bridge = this.#bridge;
 		if (!bridge) throw new Error("codemode bridge server is not running");
+		const configuredPoolWidth = this.#options.settings.parallelPoolWidth;
+		const parallelPoolWidth = Number.isFinite(configuredPoolWidth) ? Math.max(1, Math.trunc(configuredPoolWidth)) : 1;
 		if (language === "js") {
 			return new JavaScriptKernel({
 				sessionId: this.#options.sessionId,
 				cwd: this.#options.cwd,
-				parallelPoolWidth: this.#options.settings.parallelPoolWidth,
+				parallelPoolWidth,
 				onMessage,
 			});
 		}
 		const detected = this.#options.availability[language].detected;
 		if (!detected.ok) throw new Error(`No ${language} interpreter is available`);
-		const connection = { port: bridge.port, token: bridge.token };
+		const localRoots =
+			this.#options.localRoots ??
+			(this.#options.artifactsDir ? { local: join(this.#options.artifactsDir, "local") } : undefined);
+		const connection = {
+			port: bridge.port,
+			token: bridge.token,
+			parallelPoolWidth,
+			...(localRoots ? { localRoots: { ...localRoots } } : {}),
+			...(this.#options.artifactsDir ? { artifactsDir: this.#options.artifactsDir } : {}),
+		};
 		if (language === "py") {
 			return await PythonKernel.start({
 				interpreterPath: detected.path,