@agentic-kit/pi-host 0.2.0

package/esm/workspace-tools.js

@@ -0,0 +1,199 @@
+// The coding lane's tools: a workspace, as tools.
+//
+// The pi control-plane tools (`@agentic-kit/pi`) are the *schema* lane — they
+// resolve a Constructive project from the cwd and edit a tenant's database. A
+// coding run's cwd is a git clone, so those tools have no project to act on;
+// what it needs instead is the file surface of the checkout. pi's own
+// read/write/edit/bash tools live inside the pi coding agent's TUI runtime
+// rather than as `AgentTool`s an embedder can hand to `Agent`, so the four here
+// are that surface and nothing more.
+//
+// Every path is resolved inside the workspace: a model that asks for
+// `../../etc/passwd` gets an error result rather than the file, because the
+// clone is the boundary the Job was given.
+import { execFile } from 'node:child_process';
+import { mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { isInside } from './project-context';
+export const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
+export const MAX_READ_BYTES = 200_000;
+export class OutsideWorkspaceError extends Error {
+    requested;
+    cwd;
+    constructor(requested, cwd) {
+        super(`'${requested}' is outside the workspace (${cwd})`);
+        this.requested = requested;
+        this.cwd = cwd;
+        this.name = 'OutsideWorkspaceError';
+    }
+}
+function resolveInside(cwd, requested) {
+    const resolved = path.resolve(cwd, requested);
+    if (!isInside(cwd, resolved))
+        throw new OutsideWorkspaceError(requested, cwd);
+    return resolved;
+}
+function text(value) {
+    return { content: [{ type: 'text', text: value }] };
+}
+function failure(error) {
+    return text(`error: ${error instanceof Error ? error.message : String(error)}`);
+}
+async function attempt(run) {
+    try {
+        return await run();
+    }
+    catch (error) {
+        // A tool failure is the model's to recover from — a bad path or a failing
+        // command is an ordinary result it should read and retry, not a crashed
+        // run. Anything that must end the run (a gateway that cannot be reached,
+        // a thread that is gone) is raised outside a tool.
+        return failure(error);
+    }
+}
+function runCommand(command, options) {
+    return new Promise((resolve) => {
+        execFile('/bin/sh', ['-c', command], {
+            cwd: options.cwd,
+            timeout: options.timeoutMs,
+            maxBuffer: MAX_READ_BYTES,
+            ...(options.env ? { env: options.env } : {})
+        }, (error, stdout, stderr) => {
+            const code = error && typeof error.code === 'number'
+                ? error.code
+                : error
+                    ? 1
+                    : 0;
+            resolve({ stdout, stderr: stderr + (error && !stderr ? String(error.message) : ''), code });
+        });
+    });
+}
+/**
+ * Read, write, edit, list, run. Named the way pi names them so a persona's
+ * tool allowlist reads the same in either host.
+ */
+export function createWorkspaceTools(options) {
+    const cwd = path.resolve(options.cwd);
+    const timeoutMs = options.commandTimeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
+    return [
+        {
+            name: 'read_file',
+            label: 'Read a file',
+            description: 'Read a UTF-8 file from the workspace, relative to its root.',
+            parameters: {
+                type: 'object',
+                properties: { path: { type: 'string', description: 'Path relative to the workspace root' } },
+                required: ['path'],
+                additionalProperties: false
+            },
+            execute: (_id, params) => attempt(async () => {
+                const file = resolveInside(cwd, String(params.path));
+                const info = await stat(file);
+                if (info.size > MAX_READ_BYTES) {
+                    return text(`error: ${params.path} is ${info.size} bytes — too large to read whole`);
+                }
+                return text(await readFile(file, 'utf-8'));
+            })
+        },
+        {
+            name: 'write_file',
+            label: 'Write a file',
+            description: 'Write a UTF-8 file in the workspace, creating parent directories. Replaces the whole file.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path relative to the workspace root' },
+                    content: { type: 'string', description: 'The file\'s new contents' }
+                },
+                required: ['path', 'content'],
+                additionalProperties: false
+            },
+            execute: (_id, params) => attempt(async () => {
+                const file = resolveInside(cwd, String(params.path));
+                await mkdir(path.dirname(file), { recursive: true });
+                await writeFile(file, String(params.content), 'utf-8');
+                return text(`wrote ${params.path}`);
+            })
+        },
+        {
+            name: 'edit_file',
+            label: 'Edit a file',
+            description: 'Replace an exact string in a file. The string must occur exactly once, so an ambiguous edit fails rather than guessing.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path relative to the workspace root' },
+                    old_string: { type: 'string', description: 'The text to replace' },
+                    new_string: { type: 'string', description: 'What to replace it with' }
+                },
+                required: ['path', 'old_string', 'new_string'],
+                additionalProperties: false
+            },
+            execute: (_id, params) => attempt(async () => {
+                const file = resolveInside(cwd, String(params.path));
+                const before = await readFile(file, 'utf-8');
+                const target = String(params.old_string);
+                const occurrences = before.split(target).length - 1;
+                if (occurrences === 0)
+                    return text(`error: ${params.path} does not contain that text`);
+                if (occurrences > 1) {
+                    return text(`error: that text occurs ${occurrences} times in ${params.path} — include enough context to make it unique`);
+                }
+                await writeFile(file, before.replace(target, String(params.new_string)), 'utf-8');
+                return text(`edited ${params.path}`);
+            })
+        },
+        {
+            name: 'list_files',
+            label: 'List files',
+            description: 'List the entries of a directory in the workspace.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory relative to the workspace root' }
+                },
+                additionalProperties: false
+            },
+            execute: (_id, params) => attempt(async () => {
+                const dir = resolveInside(cwd, params.path === undefined ? '.' : String(params.path));
+                const entries = await readdir(dir, { withFileTypes: true });
+                const listed = entries
+                    .filter((entry) => entry.name !== '.git')
+                    .map((entry) => (entry.isDirectory() ? `${entry.name}/` : entry.name))
+                    .sort();
+                return text(listed.join('\n') || '(empty)');
+            })
+        },
+        {
+            name: 'run_command',
+            label: 'Run a command',
+            description: 'Run a shell command in the workspace root and answer with its output and exit status.',
+            parameters: {
+                type: 'object',
+                properties: { command: { type: 'string', description: 'The command line to run' } },
+                required: ['command'],
+                additionalProperties: false
+            },
+            execute: (_id, params) => attempt(async () => {
+                const result = await runCommand(String(params.command), {
+                    cwd,
+                    timeoutMs,
+                    ...(options.env ? { env: options.env } : {})
+                });
+                const parts = [
+                    result.stdout.trim() ? `stdout:\n${result.stdout.trim()}` : '',
+                    result.stderr.trim() ? `stderr:\n${result.stderr.trim()}` : '',
+                    `exit: ${result.code}`
+                ].filter(Boolean);
+                return text(parts.join('\n\n'));
+            })
+        }
+    ];
+}
+export const WORKSPACE_TOOL_NAMES = [
+    'read_file',
+    'write_file',
+    'edit_file',
+    'list_files',
+    'run_command'
+];

package/events.d.ts

@@ -0,0 +1,47 @@
+import type { AgentEvent } from '@agentic-kit/agent';
+import type { TaskWriter, TodoItem, Transcript } from '@agentic-kit/agent-conversation';
+/** Tool names whose arguments carry the agent's todo list. */
+export declare const TODO_TOOL_NAMES: string[];
+export interface TranscriptWriterOptions {
+    transcript: Transcript;
+    /** Absent when the tenant's agent module has no task surface for this run. */
+    tasks?: TaskWriter;
+    /** Tool names whose arguments carry a todo list. */
+    todoToolNames?: string[];
+}
+/**
+ * Translate a run's events into thread writes.
+ *
+ * Nothing here is best-effort: a failed write is kept and rethrown from
+ * `drain()`, because a transcript that silently lost the middle of a run is
+ * worse than a run that fails.
+ */
+export declare class TranscriptWriter {
+    private readonly options;
+    private chain;
+    private readonly pending;
+    private readonly todoToolNames;
+    private failure;
+    constructor(options: TranscriptWriterOptions);
+    /** Subscribe this writer to an agent: `agent.subscribe(writer.handler)`. */
+    readonly handler: (event: AgentEvent) => void;
+    /** Wait for every write queued so far, and surface the first that failed. */
+    drain(): Promise<void>;
+    private enqueue;
+    private apply;
+    private syncTodos;
+}
+/** The prose of an assistant message; thinking and tool calls are not prose. */
+export declare function assistantText(message: {
+    content: unknown;
+}): string;
+/** The text of a tool result, as the transcript records it. */
+export declare function resultText(result: {
+    content: unknown;
+}): string;
+/**
+ * The todo list a todo tool was called with. Returns null when the arguments do
+ * not carry one; throws when they carry a malformed one, because a todo list the
+ * tasks table cannot represent is a bug rather than an absence.
+ */
+export declare function parseTodos(args: Record<string, unknown>): TodoItem[] | null;

package/events.js

@@ -0,0 +1,168 @@
+"use strict";
+// `AgentEvent` → the thread.
+//
+// `@agentic-kit/agent` already emits everything a transcript needs, so this is a
+// translation and nothing else: prose to a message, a tool call to a ToolPart
+// rewritten in place as it runs, the agent's todo list to `agent_task` rows.
+// Writes are serialized through one promise chain so the thread's order matches
+// the run's order; `drain()` is how a composition root waits for the tail.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranscriptWriter = exports.TODO_TOOL_NAMES = void 0;
+exports.assistantText = assistantText;
+exports.resultText = resultText;
+exports.parseTodos = parseTodos;
+const agent_conversation_1 = require("@agentic-kit/agent-conversation");
+const coerce_1 = require("@constructive-io/coerce");
+/** The text of a content block, or '' when the block carries none. */
+const blockText = (block) => (0, coerce_1.asString)((0, coerce_1.asRecord)(block)?.text) ?? '';
+/** Tool names whose arguments carry the agent's todo list. */
+exports.TODO_TOOL_NAMES = ['todo_write', 'update_plan', 'write_todos'];
+/**
+ * Translate a run's events into thread writes.
+ *
+ * Nothing here is best-effort: a failed write is kept and rethrown from
+ * `drain()`, because a transcript that silently lost the middle of a run is
+ * worse than a run that fails.
+ */
+class TranscriptWriter {
+    options;
+    chain = Promise.resolve();
+    pending = new Map();
+    todoToolNames;
+    failure;
+    constructor(options) {
+        this.options = options;
+        this.todoToolNames = new Set(options.todoToolNames ?? exports.TODO_TOOL_NAMES);
+    }
+    /** Subscribe this writer to an agent: `agent.subscribe(writer.handler)`. */
+    handler = (event) => {
+        this.enqueue(() => this.apply(event));
+    };
+    /** Wait for every write queued so far, and surface the first that failed. */
+    async drain() {
+        await this.chain;
+        if (this.failure !== undefined) {
+            const failure = this.failure;
+            this.failure = undefined;
+            throw failure;
+        }
+    }
+    enqueue(work) {
+        this.chain = this.chain.then(async () => {
+            if (this.failure !== undefined)
+                return;
+            try {
+                await work();
+            }
+            catch (error) {
+                this.failure = error;
+            }
+        });
+    }
+    async apply(event) {
+        switch (event.type) {
+            case 'message_end': {
+                if (event.message.role !== 'assistant')
+                    return;
+                const text = assistantText(event.message);
+                if (text)
+                    await this.options.transcript.appendText(text);
+                return;
+            }
+            case 'tool_execution_start': {
+                const part = (0, agent_conversation_1.toolPart)({
+                    toolName: event.toolName,
+                    toolCallId: event.toolCallId,
+                    input: event.args
+                });
+                const message = await this.options.transcript.appendToolPart(part);
+                this.pending.set(event.toolCallId, { messageId: message.id, part });
+                await this.syncTodos(event.toolName, event.args);
+                return;
+            }
+            case 'tool_execution_end': {
+                const call = this.pending.get(event.toolCallId);
+                if (!call) {
+                    throw new Error(`tool call ${event.toolCallId} (${event.toolName}) ended without having started`);
+                }
+                this.pending.delete(event.toolCallId);
+                const output = resultText(event.result);
+                const next = event.isError
+                    ? (0, agent_conversation_1.failToolPart)(call.part, output || 'The tool failed without a message')
+                    : (0, agent_conversation_1.completeToolPart)(call.part, output);
+                await this.options.transcript.updateToolPart(call.messageId, next);
+                return;
+            }
+            case 'tool_decision_pending': {
+                // The lane's tools declare no `decision` schema — approval is the
+                // harness gate, answered through the thread. An in-band decision would
+                // stall the run forever, so it fails loudly instead.
+                throw new Error(`tool ${event.toolName} (${event.toolCallId}) asked for an in-band decision, which this runner does not serve`);
+            }
+            default:
+                return;
+        }
+    }
+    async syncTodos(toolName, args) {
+        if (!this.options.tasks || !this.todoToolNames.has(toolName))
+            return;
+        const todos = parseTodos(args);
+        if (todos)
+            await this.options.tasks.sync(todos);
+    }
+}
+exports.TranscriptWriter = TranscriptWriter;
+/** The prose of an assistant message; thinking and tool calls are not prose. */
+function assistantText(message) {
+    const content = message.content;
+    const prose = (0, coerce_1.asString)(content);
+    if (prose)
+        return prose.trim();
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((block) => ((0, coerce_1.asRecord)(block)?.type === 'text' ? blockText(block) : ''))
+        .join('')
+        .trim();
+}
+/** The text of a tool result, as the transcript records it. */
+function resultText(result) {
+    const content = result.content;
+    const text = (0, coerce_1.asString)(content);
+    if (text)
+        return text;
+    if (!Array.isArray(content))
+        return '';
+    return content.map(blockText).join('').trim();
+}
+const TODO_STATUSES = ['pending', 'in_progress', 'completed', 'failed'];
+/**
+ * The todo list a todo tool was called with. Returns null when the arguments do
+ * not carry one; throws when they carry a malformed one, because a todo list the
+ * tasks table cannot represent is a bug rather than an absence.
+ */
+function parseTodos(args) {
+    const raw = args.todos ?? args.items ?? args.plan;
+    if (raw === undefined || raw === null)
+        return null;
+    if (!Array.isArray(raw))
+        throw new Error('todo tool called with a non-list todo argument');
+    return raw.map((entry, index) => {
+        const item = (0, coerce_1.asRecord)(entry);
+        if (!item)
+            throw new Error(`todo ${index} is not an object`);
+        const description = (0, coerce_1.asString)(item.description ?? item.content ?? item.title ?? item.step);
+        if (!description)
+            throw new Error(`todo ${index} carries no description`);
+        const status = (0, coerce_1.asOneOf)(item.status ?? 'pending', TODO_STATUSES);
+        if (!status) {
+            throw new Error(`todo ${index} has status "${String(item.status)}", which agent_task does not model`);
+        }
+        const error = (0, coerce_1.asString)(item.error);
+        return {
+            description: description.trim(),
+            status,
+            ...(error ? { error } : {})
+        };
+    });
+}

package/gate.d.ts

@@ -0,0 +1,35 @@
+import type { Inbox, ToolPart, Transcript } from '@agentic-kit/agent-conversation';
+import type { GateHost } from '@agentic-kit/harness';
+export interface ThreadGateHostOptions {
+    transcript: Transcript;
+    inbox: Inbox;
+    /** How long a pending approval waits before it is treated as declined. */
+    approvalTimeoutMs?: number;
+    /** Approval ids, as a value — a suite passes a counter. */
+    newApprovalId?: () => string;
+    /** Called when the human asked the run to stop while an approval was pending. */
+    onCancel?: (reason: string | undefined) => void;
+    /** Called with every tool part the gate writes, so a caller can trace the run. */
+    onToolPart?: (part: ToolPart) => void;
+}
+export declare const DEFAULT_APPROVAL_TIMEOUT_MS: number;
+/**
+ * The harness's `GateHost` plus the drain its one synchronous method needs.
+ *
+ * `notifyToolSkipped` returns void, so its transcript write cannot be awaited
+ * where it is called. It is queued instead, and `drain()` — awaited by the
+ * composition root once the run ends — rethrows the first failure, so a write
+ * that fails still fails the Job rather than disappearing into a `catch`.
+ */
+export type ThreadGateHost = GateHost & {
+    drain(): Promise<void>;
+};
+/**
+ * A `GateHost` whose UI is the thread.
+ *
+ * The pending call is one message whose single ToolPart is rewritten in place as
+ * the decision arrives, so the thread reads as a conversation and the state
+ * machine in `@agentic-kit/agent-conversation` is the only place the
+ * lifecycle is enforced.
+ */
+export declare function createThreadGateHost(options: ThreadGateHostOptions): ThreadGateHost;

package/gate.js

@@ -0,0 +1,92 @@
+"use strict";
+// The GateHost the harness already defines, answered by the conversation.
+//
+// `@agentic-kit/harness` owns *what* is gated (`MUTATING_DB_TOOLS`), the prompt
+// wording (`buildConfirmPrompt`) and the decline guard; a host only supplies the
+// three capabilities in `GateHost`. Desktop answers `confirmTool` with a dialog.
+// A Job answers it with a message: it writes the tool call into the thread at
+// `approval-requested` and waits for the human to echo the part back at
+// `approval-responded`. That is the same contract, resolved asynchronously —
+// which is exactly why the runner reports `hasUI: true`. Reporting false would
+// tell the gate no decision can ever be obtained and block every mutating tool.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_APPROVAL_TIMEOUT_MS = void 0;
+exports.createThreadGateHost = createThreadGateHost;
+const agent_conversation_1 = require("@agentic-kit/agent-conversation");
+exports.DEFAULT_APPROVAL_TIMEOUT_MS = 15 * 60 * 1000;
+/**
+ * A `GateHost` whose UI is the thread.
+ *
+ * The pending call is one message whose single ToolPart is rewritten in place as
+ * the decision arrives, so the thread reads as a conversation and the state
+ * machine in `@agentic-kit/agent-conversation` is the only place the
+ * lifecycle is enforced.
+ */
+function createThreadGateHost(options) {
+    const { transcript, inbox, approvalTimeoutMs = exports.DEFAULT_APPROVAL_TIMEOUT_MS, newApprovalId = () => `approval-${Math.random().toString(36).slice(2, 10)}`, onCancel, onToolPart } = options;
+    const emit = (part) => {
+        onToolPart?.(part);
+        return part;
+    };
+    const confirmTool = async (toolCallId, title, message, preview) => {
+        const pending = (0, agent_conversation_1.toolPart)({
+            toolName: 'confirm',
+            toolCallId,
+            input: { title, message, ...(preview ? { preview } : {}) }
+        });
+        const requested = emit((0, agent_conversation_1.requestApproval)(pending, newApprovalId()));
+        const written = await transcript.appendToolPart(requested);
+        const outcome = await inbox.waitFor(agent_conversation_1.isApprovalEvent, { timeoutMs: approvalTimeoutMs });
+        if (outcome.event && outcome.event.toolCallId === toolCallId) {
+            // Two writes on a decline, on purpose: `approval-responded` is the human's
+            // answer and `output-denied` is the call's outcome, and the transcript is
+            // read as a history — collapsing them would lose who declined and why.
+            const responded = (0, agent_conversation_1.respondToApproval)(requested, {
+                approved: outcome.event.approved,
+                reason: outcome.event.reason
+            });
+            await transcript.updateToolPart(written.id, emit(responded));
+            if (!outcome.event.approved) {
+                await transcript.updateToolPart(written.id, emit((0, agent_conversation_1.denyToolPart)(responded, outcome.event.reason ?? 'Declined by the user')));
+            }
+            return outcome.event.approved;
+        }
+        if (outcome.event) {
+            // A decision arrived for a call this gate is not waiting on. The gate is
+            // serial — one pending confirm at a time — so this is a malformed client,
+            // not a race, and silently dropping it would strand the run.
+            throw new Error(`approval for tool call ${outcome.event.toolCallId} arrived while ${toolCallId} was pending`);
+        }
+        if (outcome.cancelled) {
+            onCancel?.(outcome.cancelled.reason);
+            await transcript.updateToolPart(written.id, emit((0, agent_conversation_1.denyToolPart)(requested, outcome.cancelled.reason ?? 'Cancelled by the user')));
+            return false;
+        }
+        await transcript.updateToolPart(written.id, emit((0, agent_conversation_1.failToolPart)(requested, `No decision within ${Math.round(approvalTimeoutMs / 1000)}s`)));
+        return false;
+    };
+    // Queued notices, serialized so the transcript keeps the order the gate saw,
+    // and their first failure, kept for `drain()` to rethrow.
+    let queue = Promise.resolve();
+    let failure;
+    return {
+        hasUI: true,
+        confirmTool,
+        notifyToolSkipped: (toolCallId) => {
+            queue = queue.then(async () => {
+                try {
+                    await transcript.appendText(`Skipped a repeat of a declined tool call (${toolCallId}).`);
+                }
+                catch (error) {
+                    failure ??= error;
+                }
+            });
+        },
+        drain: async () => {
+            await queue;
+            if (failure !== undefined) {
+                throw new Error(`failed to write a skipped-tool notice to the thread: ${failure instanceof Error ? failure.message : String(failure)}`, { cause: failure });
+            }
+        }
+    };
+}

package/host.d.ts

@@ -0,0 +1,18 @@
+import type { ToolsHost } from '@agentic-kit/pi/host';
+export interface PiHostValues {
+    userId: string;
+    accessToken: string;
+    apiKey?: string;
+    apiEndpoint?: string;
+    modulesEndpoint?: string;
+}
+/**
+ * A `ToolsHost` built from values.
+ *
+ * The desktop host reads an Electron singleton; a Job has a token and two
+ * endpoints, and nothing else. It offers no preview token, no data-auth broker
+ * and no step-up, so the data-plane tools decline cleanly rather than half-work,
+ * and no `deliverSecret`, so `create_api_key` refuses to mint a secret that has
+ * nowhere safe to go.
+ */
+export declare function createPiToolsHost(values: PiHostValues): ToolsHost;

package/host.js

@@ -0,0 +1,29 @@
+"use strict";
+// The `ToolsHost` a Job can honestly provide.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPiToolsHost = createPiToolsHost;
+/**
+ * A `ToolsHost` built from values.
+ *
+ * The desktop host reads an Electron singleton; a Job has a token and two
+ * endpoints, and nothing else. It offers no preview token, no data-auth broker
+ * and no step-up, so the data-plane tools decline cleanly rather than half-work,
+ * and no `deliverSecret`, so `create_api_key` refuses to mint a secret that has
+ * nowhere safe to go.
+ */
+function createPiToolsHost(values) {
+    if (!values.accessToken)
+        throw new Error('a pi tools host needs an access token');
+    return {
+        account: () => ({
+            userId: values.userId,
+            accessToken: values.accessToken,
+            ...(values.apiKey ? { apiKey: values.apiKey } : {})
+        }),
+        backendConfig: () => ({
+            ...(values.apiEndpoint ? { apiEndpoint: values.apiEndpoint } : {}),
+            ...(values.modulesEndpoint ? { modulesEndpoint: values.modulesEndpoint } : {})
+        }),
+        signInHint: 'This run was launched without a usable platform token.'
+    };
+}

package/index.d.ts

@@ -0,0 +1,16 @@
+export type { TranscriptWriterOptions } from './events';
+export { assistantText, parseTodos, resultText, TODO_TOOL_NAMES, TranscriptWriter } from './events';
+export type { ThreadGateHost, ThreadGateHostOptions } from './gate';
+export { createThreadGateHost, DEFAULT_APPROVAL_TIMEOUT_MS } from './gate';
+export type { PiHostValues } from './host';
+export { createPiToolsHost } from './host';
+export type { MeteredIdentity, MeteredModel, MeteredModelOptions } from './model';
+export { createMeteredModel, gatewayApiRoot, meteringHeaders } from './model';
+export type { LoadPersonaInput, PersonaConfig, PersonaRow, PersonaSelection, SelectPersonaInput, SkillResource } from './persona';
+export { loadPersona, loadPersonaSkills, PersonaModelUnresolvedError, PersonaNotFoundError, selectPersona, UnknownPersonaToolError } from './persona';
+export type { ProjectContextRequest } from './project-context';
+export { isInside, materializeProjectContext, ProjectContextInsideWorkTreeError } from './project-context';
+export type { GatedToolset, GatedToolsetOptions } from './tools';
+export { CLONE_GATE_DEPS, createGatedToolset } from './tools';
+export type { WorkspaceToolsOptions } from './workspace-tools';
+export { createWorkspaceTools, DEFAULT_COMMAND_TIMEOUT_MS, MAX_READ_BYTES, OutsideWorkspaceError, WORKSPACE_TOOL_NAMES } from './workspace-tools';

package/index.js

@@ -0,0 +1,42 @@
+"use strict";
+// @agentic-kit/pi-host — the host half of a headless agent run: the
+// harness's `GateHost` answered by the conversation thread, persona selection,
+// the gated toolset, and `AgentEvent` → transcript. Every dependency arrives as
+// a value; nothing here knows what a `ctx` is.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKSPACE_TOOL_NAMES = exports.OutsideWorkspaceError = exports.MAX_READ_BYTES = exports.DEFAULT_COMMAND_TIMEOUT_MS = exports.createWorkspaceTools = exports.createGatedToolset = exports.CLONE_GATE_DEPS = exports.ProjectContextInsideWorkTreeError = exports.materializeProjectContext = exports.isInside = exports.UnknownPersonaToolError = exports.selectPersona = exports.PersonaNotFoundError = exports.PersonaModelUnresolvedError = exports.loadPersonaSkills = exports.loadPersona = exports.meteringHeaders = exports.gatewayApiRoot = exports.createMeteredModel = exports.createPiToolsHost = exports.DEFAULT_APPROVAL_TIMEOUT_MS = exports.createThreadGateHost = exports.TranscriptWriter = exports.TODO_TOOL_NAMES = exports.resultText = exports.parseTodos = exports.assistantText = void 0;
+var events_1 = require("./events");
+Object.defineProperty(exports, "assistantText", { enumerable: true, get: function () { return events_1.assistantText; } });
+Object.defineProperty(exports, "parseTodos", { enumerable: true, get: function () { return events_1.parseTodos; } });
+Object.defineProperty(exports, "resultText", { enumerable: true, get: function () { return events_1.resultText; } });
+Object.defineProperty(exports, "TODO_TOOL_NAMES", { enumerable: true, get: function () { return events_1.TODO_TOOL_NAMES; } });
+Object.defineProperty(exports, "TranscriptWriter", { enumerable: true, get: function () { return events_1.TranscriptWriter; } });
+var gate_1 = require("./gate");
+Object.defineProperty(exports, "createThreadGateHost", { enumerable: true, get: function () { return gate_1.createThreadGateHost; } });
+Object.defineProperty(exports, "DEFAULT_APPROVAL_TIMEOUT_MS", { enumerable: true, get: function () { return gate_1.DEFAULT_APPROVAL_TIMEOUT_MS; } });
+var host_1 = require("./host");
+Object.defineProperty(exports, "createPiToolsHost", { enumerable: true, get: function () { return host_1.createPiToolsHost; } });
+var model_1 = require("./model");
+Object.defineProperty(exports, "createMeteredModel", { enumerable: true, get: function () { return model_1.createMeteredModel; } });
+Object.defineProperty(exports, "gatewayApiRoot", { enumerable: true, get: function () { return model_1.gatewayApiRoot; } });
+Object.defineProperty(exports, "meteringHeaders", { enumerable: true, get: function () { return model_1.meteringHeaders; } });
+var persona_1 = require("./persona");
+Object.defineProperty(exports, "loadPersona", { enumerable: true, get: function () { return persona_1.loadPersona; } });
+Object.defineProperty(exports, "loadPersonaSkills", { enumerable: true, get: function () { return persona_1.loadPersonaSkills; } });
+Object.defineProperty(exports, "PersonaModelUnresolvedError", { enumerable: true, get: function () { return persona_1.PersonaModelUnresolvedError; } });
+Object.defineProperty(exports, "PersonaNotFoundError", { enumerable: true, get: function () { return persona_1.PersonaNotFoundError; } });
+Object.defineProperty(exports, "selectPersona", { enumerable: true, get: function () { return persona_1.selectPersona; } });
+Object.defineProperty(exports, "UnknownPersonaToolError", { enumerable: true, get: function () { return persona_1.UnknownPersonaToolError; } });
+var project_context_1 = require("./project-context");
+Object.defineProperty(exports, "isInside", { enumerable: true, get: function () { return project_context_1.isInside; } });
+Object.defineProperty(exports, "materializeProjectContext", { enumerable: true, get: function () { return project_context_1.materializeProjectContext; } });
+Object.defineProperty(exports, "ProjectContextInsideWorkTreeError", { enumerable: true, get: function () { return project_context_1.ProjectContextInsideWorkTreeError; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "CLONE_GATE_DEPS", { enumerable: true, get: function () { return tools_1.CLONE_GATE_DEPS; } });
+Object.defineProperty(exports, "createGatedToolset", { enumerable: true, get: function () { return tools_1.createGatedToolset; } });
+var workspace_tools_1 = require("./workspace-tools");
+Object.defineProperty(exports, "createWorkspaceTools", { enumerable: true, get: function () { return workspace_tools_1.createWorkspaceTools; } });
+Object.defineProperty(exports, "DEFAULT_COMMAND_TIMEOUT_MS", { enumerable: true, get: function () { return workspace_tools_1.DEFAULT_COMMAND_TIMEOUT_MS; } });
+Object.defineProperty(exports, "MAX_READ_BYTES", { enumerable: true, get: function () { return workspace_tools_1.MAX_READ_BYTES; } });
+Object.defineProperty(exports, "OutsideWorkspaceError", { enumerable: true, get: function () { return workspace_tools_1.OutsideWorkspaceError; } });
+Object.defineProperty(exports, "WORKSPACE_TOOL_NAMES", { enumerable: true, get: function () { return workspace_tools_1.WORKSPACE_TOOL_NAMES; } });