@alpacakit/agents 0.1.0-beta.19

package/dist/agents/openai-compatible/fetch-engine.js

@@ -0,0 +1,216 @@
+import { AGENT_ERROR_CODE, AgentError, AUTH_FAILURE_REASON, isAgentError, NOT_AVAILABLE_CAUSE, } from "../../core/error.js";
+import { redactSecrets } from "../../core/redact.js";
+import { parseCooldownHint } from "../../kernel/classify.js";
+import { createDefaultOpenAiCompatibleResponseDecoders, } from "./response.js";
+const CHAT_COMPLETIONS_PATH = "chat/completions";
+const HTTP_METHOD_POST = "POST";
+const OPENAI_COMPATIBLE_HTTP_HEADER = {
+    authorizationCanonical: "Authorization",
+    authorizationLookup: "authorization",
+    contentType: "content-type",
+    retryAfter: "retry-after",
+};
+const HTTP_CONTENT_TYPE = {
+    json: "application/json",
+};
+const HTTP_STATUS = {
+    unauthorized: 401,
+    forbidden: 403,
+    rateLimited: 429,
+};
+const AUTH_REASON_BY_STATUS = {
+    [HTTP_STATUS.unauthorized]: AUTH_FAILURE_REASON.unauthorized,
+    [HTTP_STATUS.forbidden]: AUTH_FAILURE_REASON.forbidden,
+};
+const RETRY_AFTER_COOLDOWN_HINT_PREFIX = "retry-after: ";
+const CHAT_COMPLETION_REQUEST_FIELD = {
+    messages: "messages",
+    model: "model",
+    stream: "stream",
+};
+const CHAT_COMPLETION_ROLE = {
+    user: "user",
+};
+const CHAT_COMPLETION_STREAMING = true;
+const DEFAULT_MAX_ATTEMPTS = 2;
+const STDERR_TAIL_CHARS = 2_000;
+export class FetchOpenAiCompatibleEngine {
+    decoders;
+    retryPolicy;
+    failurePolicy;
+    constructor(dependencies = {}) {
+        this.decoders =
+            dependencies.decoders ?? createDefaultOpenAiCompatibleResponseDecoders();
+        this.retryPolicy =
+            dependencies.retryPolicy ?? new DefaultOpenAiCompatibleRetryPolicy();
+        this.failurePolicy =
+            dependencies.failurePolicy ??
+                new DefaultOpenAiCompatibleHttpFailurePolicy();
+    }
+    async doctorChecks() {
+        return [];
+    }
+    async *run(config, options, ctx) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= this.retryPolicy.maxAttempts; attempt += 1) {
+            // Once a decoder has yielded an event, the attempt is no longer
+            // retryable: a second attempt would re-stream and duplicate output.
+            let emitted = false;
+            try {
+                const response = await ctx.http.fetch(chatCompletionsUrl(config.baseUrl), {
+                    method: HTTP_METHOD_POST,
+                    headers: requestHeaders(config),
+                    body: JSON.stringify(requestBody(config, options)),
+                    signal: ctx.signal,
+                });
+                const failure = await this.failurePolicy.errorFor(response, ctx);
+                if (failure !== null) {
+                    throw failure;
+                }
+                const decoded = this.decoderFor(response).decode(response, config.model);
+                for (;;) {
+                    const next = await decoded.next();
+                    if (next.done) {
+                        return next.value;
+                    }
+                    emitted = true;
+                    yield next.value;
+                }
+            }
+            catch (error) {
+                const normalized = normalizeRunError(error);
+                if (emitted || !this.retryPolicy.shouldRetry(normalized, attempt)) {
+                    throw normalized;
+                }
+                lastError = normalized;
+            }
+        }
+        throw lastError ?? unreachableError();
+    }
+    decoderFor(response) {
+        const decoder = this.decoders.find((candidate) => candidate.supports(response));
+        if (decoder === undefined) {
+            throw new AgentError({
+                code: AGENT_ERROR_CODE.failed,
+                message: "OpenAI-compatible endpoint returned an unsupported response",
+                data: { exitCode: null, stdoutTail: null, stderrTail: null },
+            });
+        }
+        return decoder;
+    }
+}
+export class DefaultOpenAiCompatibleRetryPolicy {
+    maxAttempts = DEFAULT_MAX_ATTEMPTS;
+    shouldRetry(error, attempt) {
+        return attempt < this.maxAttempts && isRetryableRunError(error);
+    }
+}
+export class DefaultOpenAiCompatibleHttpFailurePolicy {
+    handlers = [
+        authFailureHandler,
+        quotaFailureHandler,
+        genericHttpFailureHandler,
+    ];
+    async errorFor(response, ctx) {
+        const handler = this.handlers.find((candidate) => candidate.matches(response));
+        return handler === undefined ? null : handler.errorFor(response, ctx);
+    }
+}
+const authFailureHandler = {
+    matches: (response) => isAuthHttpStatus(response.status),
+    errorFor: async (response) => new AgentError({
+        code: AGENT_ERROR_CODE.auth,
+        message: `OpenAI-compatible endpoint rejected authentication with HTTP ${response.status}`,
+        data: {
+            reason: AUTH_REASON_BY_STATUS[response.status],
+            detail: `HTTP ${response.status}`,
+        },
+    }),
+};
+const quotaFailureHandler = {
+    matches: (response) => response.status === HTTP_STATUS.rateLimited,
+    errorFor: async (response, ctx) => {
+        const retryAfter = response.headers.get(OPENAI_COMPATIBLE_HTTP_HEADER.retryAfter);
+        return new AgentError({
+            code: AGENT_ERROR_CODE.quota,
+            message: "OpenAI-compatible endpoint reported a rate limit",
+            data: {
+                cooldownUntil: retryAfter === null
+                    ? null
+                    : parseCooldownHint(`${RETRY_AFTER_COOLDOWN_HINT_PREFIX}${retryAfter}`, ctx.clock.now()),
+            },
+        });
+    },
+};
+const genericHttpFailureHandler = {
+    matches: (response) => !response.ok,
+    errorFor: async (response) => {
+        const body = await response.text().catch(() => "");
+        const redactedBody = redactSecrets(body);
+        return new AgentError({
+            code: AGENT_ERROR_CODE.failed,
+            message: `OpenAI-compatible endpoint failed with HTTP ${response.status}`,
+            data: {
+                exitCode: null,
+                stdoutTail: null,
+                stderrTail: redactedBody === "" ? null : redactedBody.slice(-STDERR_TAIL_CHARS),
+            },
+        });
+    },
+};
+function chatCompletionsUrl(baseUrl) {
+    const normalized = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    return new URL(CHAT_COMPLETIONS_PATH, normalized).toString();
+}
+function requestHeaders(config) {
+    const headers = {
+        [OPENAI_COMPATIBLE_HTTP_HEADER.contentType]: HTTP_CONTENT_TYPE.json,
+        ...config.headers,
+    };
+    if (config.apiKey !== null &&
+        !Object.keys(headers).some((name) => name.toLowerCase() ===
+            OPENAI_COMPATIBLE_HTTP_HEADER.authorizationLookup)) {
+        headers[OPENAI_COMPATIBLE_HTTP_HEADER.authorizationCanonical] =
+            `Bearer ${config.apiKey}`;
+    }
+    return headers;
+}
+function requestBody(config, options) {
+    return {
+        ...config.requestParams,
+        [CHAT_COMPLETION_REQUEST_FIELD.model]: options.model ?? config.model,
+        [CHAT_COMPLETION_REQUEST_FIELD.messages]: [
+            { role: CHAT_COMPLETION_ROLE.user, content: options.prompt },
+        ],
+        [CHAT_COMPLETION_REQUEST_FIELD.stream]: CHAT_COMPLETION_STREAMING,
+    };
+}
+function isAuthHttpStatus(status) {
+    return Object.hasOwn(AUTH_REASON_BY_STATUS, status);
+}
+function normalizeRunError(error) {
+    if (isAgentError(error)) {
+        return error;
+    }
+    return new AgentError({
+        code: AGENT_ERROR_CODE.notAvailable,
+        message: error instanceof Error ? error.message : String(error),
+        data: { cause: NOT_AVAILABLE_CAUSE.unreachable },
+        cause: error,
+    });
+}
+function isRetryableRunError(error) {
+    if (isAgentError(error, AGENT_ERROR_CODE.failed)) {
+        return true;
+    }
+    return (isAgentError(error, AGENT_ERROR_CODE.notAvailable) &&
+        error.data.cause === NOT_AVAILABLE_CAUSE.unreachable);
+}
+function unreachableError() {
+    return new AgentError({
+        code: AGENT_ERROR_CODE.failed,
+        message: "OpenAI-compatible endpoint failed without an error",
+        data: { exitCode: null, stdoutTail: null, stderrTail: null },
+    });
+}
+export const defaultOpenAiCompatibleEngine = new FetchOpenAiCompatibleEngine();

package/dist/agents/openai-compatible/pi/engine.d.ts

@@ -0,0 +1,32 @@
+import { type DoctorCheck } from "../../../host/capabilities.js";
+import type { OpenAiCompatibleEngine } from "../engine.js";
+import { type PiModuleLoader } from "./module.js";
+export type PiSessionEngineOptions = {
+    readonly agentDir: string;
+    readonly module?: PiModuleLoader;
+    /**
+     * Context window (tokens) advertised to pi for the configured model. Pi
+     * uses it for compaction thresholds; the OpenAI-compatible config carries
+     * no model-capability metadata, so the default is a deliberate placeholder
+     * (PI_DEFAULT_CONTEXT_WINDOW) — set this when the real window differs.
+     */
+    readonly contextWindow?: number;
+    /**
+     * Max output tokens advertised to pi for the configured model; pi passes
+     * it to the provider request, so the placeholder default
+     * (PI_DEFAULT_MAX_TOKENS) silently caps longer outputs. Override here, or
+     * per config via `requestParams.max_tokens`.
+     */
+    readonly maxTokens?: number;
+};
+/**
+ * Placeholder model capabilities: the resolved config has no metadata to
+ * derive them from, so these defaults assume a large-context model. Callers
+ * with different models override via PiSessionEngineOptions (or
+ * `requestParams.max_tokens` for the output cap alone).
+ */
+export declare const PI_DEFAULT_CONTEXT_WINDOW = 128000;
+export declare const PI_DEFAULT_MAX_TOKENS = 16384;
+export declare function piSessionEngine(options: PiSessionEngineOptions): OpenAiCompatibleEngine;
+export declare function piNodeVersionDoctorCheck(version: string): DoctorCheck;
+//# sourceMappingURL=engine.d.ts.map

package/dist/agents/openai-compatible/pi/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../../src/agents/openai-compatible/pi/engine.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,+BAA+B,CAAC;AAGvC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE3D,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAGrB,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC;IACjC;;;;;OAKG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,SAAU,CAAC;AACjD,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAQ5C,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,GAC9B,sBAAsB,CAExB;AA4ED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CASrE"}

package/dist/agents/openai-compatible/pi/engine.js

@@ -0,0 +1,98 @@
+import { AGENT_ERROR_CODE, isAgentError } from "../../../core/error.js";
+import { DOCTOR_CHECK_STATUS, } from "../../../host/capabilities.js";
+import { defaultPiModuleLoader, loadPiModule, } from "./module.js";
+import { runPiSession } from "./session.js";
+/**
+ * Placeholder model capabilities: the resolved config has no metadata to
+ * derive them from, so these defaults assume a large-context model. Callers
+ * with different models override via PiSessionEngineOptions (or
+ * `requestParams.max_tokens` for the output cap alone).
+ */
+export const PI_DEFAULT_CONTEXT_WINDOW = 128_000;
+export const PI_DEFAULT_MAX_TOKENS = 16_384;
+const MINIMUM_PI_NODE_VERSION = [22, 19, 0];
+const DOCTOR_CHECK = {
+    node: "pi:node",
+    peer: "pi:peer",
+};
+export function piSessionEngine(options) {
+    return new PiSessionEngine(options);
+}
+class PiSessionEngine {
+    agentDir;
+    moduleLoader;
+    contextWindow;
+    maxTokens;
+    constructor(options) {
+        this.agentDir = options.agentDir;
+        this.moduleLoader = options.module ?? defaultPiModuleLoader;
+        this.contextWindow = options.contextWindow ?? PI_DEFAULT_CONTEXT_WINDOW;
+        this.maxTokens = options.maxTokens ?? PI_DEFAULT_MAX_TOKENS;
+    }
+    async doctorChecks() {
+        return [
+            piNodeVersionDoctorCheck(currentNodeVersion()),
+            await this.peerDoctorCheck(),
+        ];
+    }
+    run(config, options, ctx) {
+        return this.runLoaded(config, options, ctx);
+    }
+    async *runLoaded(config, options, ctx) {
+        const module = await loadPiModule(this.moduleLoader);
+        return yield* runPiSession({
+            module,
+            agentDir: this.agentDir,
+            contextWindow: this.contextWindow,
+            maxTokens: this.maxTokens,
+            config,
+            options,
+            ctx,
+        });
+    }
+    async peerDoctorCheck() {
+        try {
+            await loadPiModule(this.moduleLoader);
+            return {
+                id: DOCTOR_CHECK.peer,
+                status: DOCTOR_CHECK_STATUS.pass,
+                detail: null,
+            };
+        }
+        catch (error) {
+            if (isAgentError(error, AGENT_ERROR_CODE.notAvailable)) {
+                return {
+                    id: DOCTOR_CHECK.peer,
+                    status: DOCTOR_CHECK_STATUS.fail,
+                    detail: error.message,
+                };
+            }
+            return {
+                id: DOCTOR_CHECK.peer,
+                status: DOCTOR_CHECK_STATUS.fail,
+                detail: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+function currentNodeVersion() {
+    return process.versions.node;
+}
+export function piNodeVersionDoctorCheck(version) {
+    const pass = isVersionAtLeast(version, MINIMUM_PI_NODE_VERSION);
+    return {
+        id: DOCTOR_CHECK.node,
+        status: pass ? DOCTOR_CHECK_STATUS.pass : DOCTOR_CHECK_STATUS.fail,
+        detail: pass
+            ? null
+            : `Pi session engine requires Node.js ${MINIMUM_PI_NODE_VERSION.join(".")} or newer`,
+    };
+}
+function isVersionAtLeast(version, minimum) {
+    const [major = 0, minor = 0, patch = 0] = version
+        .split(".")
+        .map((segment) => Number(segment));
+    return (major > minimum[0] ||
+        (major === minimum[0] &&
+            (minor > minimum[1] || (minor === minimum[1] && patch >= minimum[2]))));
+}

package/dist/agents/openai-compatible/pi/module.d.ts

@@ -0,0 +1,87 @@
+import { AgentError } from "../../../core/error.js";
+export interface PiAuthStorage {
+    setRuntimeApiKey(provider: string, apiKey: string): void;
+}
+export interface PiModelRegistry {
+    registerProvider(providerName: string, config: unknown): void;
+    find(provider: string, modelId: string): unknown;
+}
+export interface PiResourceLoader {
+    reload(): Promise<void>;
+}
+export interface PiPayloadHookSession {
+    agent?: {
+        onPayload?: (payload: unknown, model: unknown) => unknown | Promise<unknown>;
+    };
+}
+export interface PiAgentSession extends PiPayloadHookSession {
+    bindExtensions(bindings: object): Promise<void>;
+    prompt(text: string): Promise<void>;
+    subscribe?(listener: (event: unknown) => void): () => void;
+    abort?(): Promise<void>;
+    dispose(): void;
+    state?: {
+        messages?: readonly unknown[];
+    };
+}
+export interface PiBashOperations {
+    exec(command: string, cwd: string, options: {
+        onData(data: Uint8Array): void;
+        signal?: AbortSignal;
+        timeout?: number;
+        env?: Record<string, string>;
+    }): Promise<{
+        exitCode: number | null;
+    }>;
+}
+export type PiBashToolDefinitionFactory = (cwd: string, options: {
+    operations: PiBashOperations;
+}) => unknown;
+export type PiLocalBashOperationsFactory = () => PiBashOperations;
+export declare const PI_NO_TOOLS_MODE: {
+    readonly all: "all";
+    readonly builtin: "builtin";
+};
+export type PiNoToolsMode = (typeof PI_NO_TOOLS_MODE)[keyof typeof PI_NO_TOOLS_MODE];
+export interface PiModule {
+    AuthStorage: {
+        inMemory(data?: unknown): PiAuthStorage;
+    };
+    ModelRegistry: {
+        inMemory(authStorage: PiAuthStorage): PiModelRegistry;
+    };
+    DefaultResourceLoader: new (options: {
+        cwd: string;
+        agentDir: string;
+        settingsManager?: unknown;
+        additionalSkillPaths?: readonly string[];
+    }) => PiResourceLoader;
+    SessionManager: {
+        inMemory(cwd?: string): unknown;
+    };
+    SettingsManager: {
+        inMemory(settings?: unknown): unknown;
+    };
+    createAgentSession(options: {
+        cwd: string;
+        agentDir: string;
+        authStorage: PiAuthStorage;
+        modelRegistry: PiModelRegistry;
+        model: unknown;
+        resourceLoader: PiResourceLoader;
+        sessionManager: unknown;
+        settingsManager: unknown;
+        tools?: readonly string[];
+        noTools?: PiNoToolsMode;
+        customTools?: readonly unknown[];
+    }): Promise<{
+        session: PiAgentSession;
+    }>;
+    createBashToolDefinition?: PiBashToolDefinitionFactory;
+    createLocalBashOperations?: PiLocalBashOperationsFactory;
+}
+export type PiModuleLoader = () => Promise<unknown>;
+export declare const defaultPiModuleLoader: PiModuleLoader;
+export declare function loadPiModule(loader: PiModuleLoader): Promise<PiModule>;
+export declare function piPeerMissingError(cause: unknown): AgentError;
+//# sourceMappingURL=module.d.ts.map

package/dist/agents/openai-compatible/pi/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../src/agents/openai-compatible/pi/module.ts"],"names":[],"mappings":"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"}

package/dist/agents/openai-compatible/pi/module.js

@@ -0,0 +1,43 @@
+// biome-ignore-all lint/style/useNamingConvention: Pi peer exports mirror upstream PascalCase names.
+import { AGENT_ERROR_CODE, AgentError, NOT_AVAILABLE_CAUSE, } from "../../../core/error.js";
+export const PI_NO_TOOLS_MODE = {
+    all: "all",
+    builtin: "builtin",
+};
+const PI_PEER_PACKAGE = "@earendil-works/pi-coding-agent";
+const PI_PEER_MISSING_MESSAGE = "Pi session engine peer is not available";
+const REQUIRED_EXPORTS = [
+    "AuthStorage",
+    "ModelRegistry",
+    "DefaultResourceLoader",
+    "SessionManager",
+    "SettingsManager",
+    "createAgentSession",
+];
+export const defaultPiModuleLoader = () => import(PI_PEER_PACKAGE);
+export async function loadPiModule(loader) {
+    let loaded;
+    try {
+        loaded = await loader();
+    }
+    catch (error) {
+        throw piPeerMissingError(error);
+    }
+    if (typeof loaded !== "object" || loaded === null) {
+        throw piPeerMissingError(null);
+    }
+    for (const key of REQUIRED_EXPORTS) {
+        if (Reflect.get(loaded, key) === undefined) {
+            throw piPeerMissingError(null);
+        }
+    }
+    return loaded;
+}
+export function piPeerMissingError(cause) {
+    return new AgentError({
+        code: AGENT_ERROR_CODE.notAvailable,
+        message: PI_PEER_MISSING_MESSAGE,
+        data: { cause: NOT_AVAILABLE_CAUSE.engineMissing },
+        cause,
+    });
+}

package/dist/agents/openai-compatible/pi/sandbox.d.ts

@@ -0,0 +1,25 @@
+import { type Grant, type ResolvedSandbox, SANDBOX_MODE, type SandboxMode } from "../../../kernel/options.js";
+import type { PiModule, PiNoToolsMode } from "./module.js";
+export type PiToolPolicy = {
+    readonly tools?: readonly string[];
+    readonly noTools?: PiNoToolsMode;
+    readonly customTools?: readonly unknown[];
+};
+export type PiSandboxPolicyInput = {
+    readonly module: PiModule;
+    readonly workspace: string;
+};
+export type PiSandboxPolicyBuilder<M extends SandboxMode> = (sandbox: Extract<ResolvedSandbox, {
+    mode: M;
+}>, input: PiSandboxPolicyInput) => PiToolPolicy;
+export declare const piSandboxToolPolicies: {
+    full: (_sandbox: {
+        mode: typeof SANDBOX_MODE.full;
+    }, _input: PiSandboxPolicyInput) => {};
+    "read-only": (sandbox: {
+        mode: typeof SANDBOX_MODE.readOnly;
+        grants: Grant[];
+    }, input: PiSandboxPolicyInput) => PiToolPolicy;
+};
+export declare function piSandboxToolPolicy(sandbox: ResolvedSandbox, input: PiSandboxPolicyInput): PiToolPolicy;
+//# sourceMappingURL=sandbox.d.ts.map

package/dist/agents/openai-compatible/pi/sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../../../src/agents/openai-compatible/pi/sandbox.ts"],"names":[],"mappings":"AAKA,OAAO,EAEL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,YAAY,EACZ,KAAK,WAAW,EACjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,QAAQ,EAAoB,aAAa,EAAE,MAAM,aAAa,CAAC;AAE7E,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC;IACjC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,sBAAsB,CAAC,CAAC,SAAS,WAAW,IAAI,CAC1D,OAAO,EAAE,OAAO,CAAC,eAAe,EAAE;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC,EAC9C,KAAK,EAAE,oBAAoB,KACxB,YAAY,CAAC;AAWlB,eAAO,MAAM,qBAAqB;;;;;;;;CAMjC,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,oBAAoB,GAC1B,YAAY,CASd"}

package/dist/agents/openai-compatible/pi/sandbox.js

@@ -0,0 +1,69 @@
+import { AGENT_ERROR_CODE, AgentError, NOT_AVAILABLE_CAUSE, } from "../../../core/error.js";
+import { GRANT_KIND, SANDBOX_MODE, } from "../../../kernel/options.js";
+const READ_ONLY_TOOLS = ["read", "grep", "find", "ls"];
+const PI_BASH_TOOL = "bash";
+const SHELL_COMMAND_SEPARATOR = " ";
+const PI_SHELL_GRANT_MISSING_FACTORY_MESSAGE = "Pi shell grants require bash tool factory exports";
+const PI_BASH_COMMAND_NOT_ALLOWED_MESSAGE = "Pi bash command is not allowed by sandbox grants";
+const PI_BASH_COMMAND_NOT_ALLOWED_REASON = "pi bash command not allowed";
+export const piSandboxToolPolicies = {
+    [SANDBOX_MODE.full]: (_sandbox, _input) => ({}),
+    [SANDBOX_MODE.readOnly]: (sandbox, input) => readOnlyToolPolicy(sandbox.grants, input),
+};
+export function piSandboxToolPolicy(sandbox, input) {
+    // Correlated-union dispatch: TS cannot connect the indexed record row to
+    // the narrowed union member, so the one cast lives here; the `satisfies`
+    // map keeps every row's narrow signature honest.
+    const builder = piSandboxToolPolicies[sandbox.mode];
+    return builder(sandbox, input);
+}
+function readOnlyToolPolicy(grants, input) {
+    const shellCommands = grants.flatMap((grant) => grant.kind === GRANT_KIND.shell ? [grant.command] : []);
+    const toolGrants = grants.flatMap((grant) => grant.kind === GRANT_KIND.tool ? [grant.name] : []);
+    const tools = [
+        ...READ_ONLY_TOOLS,
+        ...toolGrants,
+        ...(shellCommands.length === 0 ? [] : [PI_BASH_TOOL]),
+    ];
+    return {
+        tools: [...new Set(tools)],
+        ...(shellCommands.length === 0
+            ? {}
+            : { customTools: [createGuardedBashTool(input, shellCommands)] }),
+    };
+}
+function createGuardedBashTool(input, allowlist) {
+    const createDefinition = input.module.createBashToolDefinition;
+    const createOperations = input.module.createLocalBashOperations;
+    if (createDefinition === undefined || createOperations === undefined) {
+        throw new AgentError({
+            code: AGENT_ERROR_CODE.notAvailable,
+            message: PI_SHELL_GRANT_MISSING_FACTORY_MESSAGE,
+            data: { cause: NOT_AVAILABLE_CAUSE.engineMissing },
+        });
+    }
+    const localOperations = createOperations();
+    return createDefinition(input.workspace, {
+        operations: guardedBashOperations(localOperations, allowlist),
+    });
+}
+function guardedBashOperations(operations, allowlist) {
+    return {
+        exec(command, cwd, options) {
+            assertAllowedCommand(command, allowlist);
+            return operations.exec(command, cwd, options);
+        },
+    };
+}
+function assertAllowedCommand(command, allowlist) {
+    const allowed = allowlist.some((entry) => command === entry ||
+        command.startsWith(`${entry}${SHELL_COMMAND_SEPARATOR}`));
+    if (allowed) {
+        return;
+    }
+    throw new AgentError({
+        code: AGENT_ERROR_CODE.invalidInput,
+        message: PI_BASH_COMMAND_NOT_ALLOWED_MESSAGE,
+        data: { reason: PI_BASH_COMMAND_NOT_ALLOWED_REASON },
+    });
+}

package/dist/agents/openai-compatible/pi/session.d.ts

@@ -0,0 +1,17 @@
+import type { AgentRun, RunContext } from "../../../kernel/definition.js";
+import type { ResolvedRunOptions } from "../../../kernel/options.js";
+import type { ResolvedOpenAiCompatibleConfig } from "../types.js";
+import type { PiModule } from "./module.js";
+type PiSessionRunInput = {
+    readonly module: PiModule;
+    readonly agentDir: string;
+    /** Resolved by the engine (option or placeholder default). */
+    readonly contextWindow: number;
+    readonly maxTokens: number;
+    readonly config: ResolvedOpenAiCompatibleConfig;
+    readonly options: ResolvedRunOptions;
+    readonly ctx: RunContext;
+};
+export declare function runPiSession(input: PiSessionRunInput): AgentRun;
+export {};
+//# sourceMappingURL=session.d.ts.map

package/dist/agents/openai-compatible/pi/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../src/agents/openai-compatible/pi/session.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,aAAa,CAAC;AA8E5D,KAAK,iBAAiB,GAAG;IACvB,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,8BAA8B,CAAC;IAChD,QAAQ,CAAC,OAAO,EAAE,kBAAkB,CAAC;IACrC,QAAQ,CAAC,GAAG,EAAE,UAAU,CAAC;CAC1B,CAAC;AAWF,wBAAgB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,QAAQ,CAE/D"}