@plico-ai/runtime 0.0.0-stage → 0.1.0

package/dist/tools/artifact-model-tools.js

@@ -0,0 +1,101 @@
+import { ARTIFACT_TOOL_NAMES } from "@plico-ai/core";
+import { editFile, listFiles, readFile, writeFile } from "./artifact-model-tool-operations.js";
+import { normalizeInputSchema } from "./schema.js";
+const source = "plico:artifacts";
+const maxListLimit = 1000;
+const maxReadLimit = 1000;
+export async function createArtifactModelTools() {
+    return Promise.all([
+        createDeclaredTool({
+            name: "list_files",
+            description: "List artifact files in the current workspace. Optionally filter paths with a glob pattern. Results are ordered by path and paginated.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    glob: { type: "string", minLength: 1, maxLength: 1024 },
+                    offset: { type: "integer", minimum: 0 },
+                    limit: { type: "integer", minimum: 1, maximum: maxListLimit },
+                },
+                additionalProperties: false,
+            },
+            capabilities: ["artifacts:read"],
+            approval: { required: false },
+            handler: async (input, { artifacts }) => handleArtifactTool(() => listFiles(input, artifacts)),
+        }),
+        createDeclaredTool({
+            name: "read_file",
+            description: "Read a text artifact from the current workspace by line range. Binary artifacts return metadata only. Each response is capped at 32 KiB.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", minLength: 1, maxLength: 1024 },
+                    offset: { type: "integer", minimum: 1 },
+                    limit: { type: "integer", minimum: 1, maximum: maxReadLimit },
+                },
+                required: ["path"],
+                additionalProperties: false,
+            },
+            capabilities: ["artifacts:read"],
+            approval: { required: false },
+            handler: async (input, { artifacts }) => handleArtifactTool(() => readFile(input, artifacts)),
+        }),
+        createDeclaredTool({
+            name: "write_file",
+            description: "Create or overwrite a text artifact in the current workspace. Writes are versioned. Content is limited to 1 MiB.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", minLength: 1, maxLength: 1024 },
+                    content: { type: "string" },
+                    mimeType: { type: "string", minLength: 1 },
+                },
+                required: ["path", "content"],
+                additionalProperties: false,
+            },
+            capabilities: ["artifacts:write"],
+            approval: { required: false },
+            handler: async (input, { artifacts }) => handleArtifactTool(() => writeFile(input, artifacts)),
+        }),
+        createDeclaredTool({
+            name: "edit_file",
+            description: "Replace exact text in a text artifact. The old text must match once unless replaceAll is true. Writes are versioned.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: { type: "string", minLength: 1, maxLength: 1024 },
+                    old: { type: "string", minLength: 1 },
+                    new: { type: "string" },
+                    replaceAll: { type: "boolean" },
+                },
+                required: ["path", "old", "new"],
+                additionalProperties: false,
+            },
+            capabilities: ["artifacts:write"],
+            approval: { required: false },
+            handler: async (input, { artifacts }) => handleArtifactTool(() => editFile(input, artifacts)),
+        }),
+    ]);
+}
+async function handleArtifactTool(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : String(error) };
+    }
+}
+async function createDeclaredTool(definition) {
+    if (!ARTIFACT_TOOL_NAMES.includes(definition.name))
+        throw new Error(`Unknown built-in artifact tool: ${definition.name}`);
+    const schema = await normalizeInputSchema(definition.inputSchema, source, source);
+    return {
+        ...definition,
+        source,
+        inputSchema: schema.jsonSchema,
+        validateInput: async (input) => {
+            const result = await schema.parse(input);
+            return result.success ? undefined : result.error;
+        },
+        parseInput: schema.parse,
+    };
+}

package/dist/tools/discover.d.ts

@@ -0,0 +1,4 @@
+import { type LoadedProject } from "@plico-ai/core";
+import type { DeclaredTool } from "../types/index.js";
+export declare function discoverToolFiles(project: LoadedProject): Promise<string[]>;
+export declare function discoverTools(project: LoadedProject): Promise<DeclaredTool[]>;

package/dist/tools/discover.js

@@ -0,0 +1,34 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { ARTIFACT_TOOL_NAMES, getProjectPaths, getProjectRelativePaths, SKILL_TOOL_NAME, } from "@plico-ai/core";
+import { loadToolFile } from "./load.js";
+export async function discoverToolFiles(project) {
+    const projectPaths = getProjectPaths(project.root);
+    const entries = (await readdir(projectPaths.directories.tools, { withFileTypes: true }))
+        .filter((entry) => !entry.isDirectory() && entry.name.endsWith(".tool.ts"))
+        .map((entry) => entry.name)
+        .sort((left, right) => left.localeCompare(right));
+    return entries;
+}
+export async function discoverTools(project) {
+    const relativePaths = getProjectRelativePaths();
+    const projectPaths = getProjectPaths(project.root);
+    const entries = await discoverToolFiles(project);
+    const tools = [];
+    const sources = new Map();
+    for (const entry of entries) {
+        const source = `${relativePaths.directories.tools}/${entry}`;
+        const tool = await loadToolFile(join(projectPaths.directories.tools, entry), source);
+        if (ARTIFACT_TOOL_NAMES.includes(tool.name))
+            throw new Error(`Tool name "${tool.name}" is reserved by Plico's artifact tools`);
+        if (tool.name === SKILL_TOOL_NAME)
+            throw new Error(`Tool name "${tool.name}" is reserved by Plico's skill loader`);
+        const first = sources.get(tool.name);
+        if (first) {
+            throw new Error(`Duplicate tool name "${tool.name}" declared in ${first} and ${source}`);
+        }
+        sources.set(tool.name, source);
+        tools.push(tool);
+    }
+    return tools;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,3 @@
+export { discoverToolFiles, discoverTools } from "./discover.js";
+export { loadToolFile } from "./load.js";
+export { isJsonSchema, normalizeInputSchema, } from "./schema.js";

package/dist/tools/index.js

@@ -0,0 +1,3 @@
+export { discoverToolFiles, discoverTools } from "./discover.js";
+export { loadToolFile } from "./load.js";
+export { isJsonSchema, normalizeInputSchema, } from "./schema.js";

package/dist/tools/load.d.ts

@@ -0,0 +1,2 @@
+import type { DeclaredTool } from "../types/index.js";
+export declare function loadToolFile(toolPath: string, source: string): Promise<DeclaredTool>;

package/dist/tools/load.js

@@ -0,0 +1,83 @@
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, extname, isAbsolute, join, parse, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { installAuthoringFallback } from "@plico-ai/core";
+import { register as registerCjs, require as tsxRequire } from "tsx/cjs/api";
+import { register as registerEsm } from "tsx/esm/api";
+import { isRecord } from "../guards.js";
+import { normalizeDeclaredTool } from "./normalize.js";
+let cjsRegistered = false;
+let esmRegistered = false;
+let loadSequence = 0;
+export async function loadToolFile(toolPath, source) {
+    installAuthoringFallback();
+    const module = (await hasModulePackageScope(toolPath))
+        ? await importToolModule(toolPath)
+        : importCommonJsTool(toolPath);
+    const exportedTool = readDefaultExport(module, source);
+    return normalizeDeclaredTool(exportedTool, source, toolPath);
+}
+async function importToolModule(toolPath) {
+    if (!esmRegistered) {
+        registerEsm();
+        esmRegistered = true;
+    }
+    const url = new URL(pathToFileURL(toolPath).href);
+    url.searchParams.set("plicoLoad", String(++loadSequence));
+    return import(url.href);
+}
+function importCommonJsTool(toolPath) {
+    if (!cjsRegistered) {
+        registerCjs();
+        cjsRegistered = true;
+    }
+    const require = createRequire(import.meta.url);
+    clearProjectToolCache(toolPath);
+    return tsxRequire(require.resolve(toolPath), import.meta.url);
+}
+function clearProjectToolCache(toolPath) {
+    const toolsDirectory = findToolsDirectory(dirname(toolPath));
+    for (const cachedPath of Object.keys(tsxRequire.cache)) {
+        const sourcePath = cachedPath.split("?", 1)[0];
+        if (!sourcePath)
+            continue;
+        if (extname(sourcePath) !== ".ts")
+            continue;
+        const pathFromTools = relative(toolsDirectory, sourcePath);
+        if (pathFromTools === "" || (!pathFromTools.startsWith("..") && !isAbsolute(pathFromTools))) {
+            delete tsxRequire.cache[cachedPath];
+        }
+    }
+}
+function findToolsDirectory(directory) {
+    if (directory === parse(directory).root)
+        return directory;
+    if (directory.split(/[\\/]/).at(-1) === "tools")
+        return directory;
+    return findToolsDirectory(dirname(directory));
+}
+async function hasModulePackageScope(filePath) {
+    let directory = dirname(filePath);
+    const filesystemRoot = parse(directory).root;
+    while (true) {
+        try {
+            const packageJson = JSON.parse(await readFile(join(directory, "package.json"), "utf8"));
+            return packageJson.type === "module";
+        }
+        catch (error) {
+            if (!error || typeof error !== "object" || !("code" in error) || error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+        if (directory === filesystemRoot)
+            return false;
+        directory = dirname(directory);
+    }
+}
+function readDefaultExport(toolModule, source) {
+    if (!isRecord(toolModule) || !Object.hasOwn(toolModule, "default")) {
+        throw new Error(`${source} must default export a declared tool`);
+    }
+    return toolModule.default;
+}

package/dist/tools/normalize.d.ts

@@ -0,0 +1,2 @@
+import type { DeclaredTool } from "../types/index.js";
+export declare function normalizeDeclaredTool(value: unknown, source: string, toolPath: string): Promise<DeclaredTool>;

package/dist/tools/normalize.js

@@ -0,0 +1,48 @@
+import { isRecord } from "../guards.js";
+import { normalizeInputSchema } from "./schema.js";
+export async function normalizeDeclaredTool(value, source, toolPath) {
+    if (!isRecord(value)) {
+        throw new Error(`${source} must default export a declared tool object`);
+    }
+    const { name, description, inputSchema, capabilities, approval, handler } = value;
+    if (typeof name !== "string") {
+        throw new Error(`${source} tool name must be a string`);
+    }
+    if (!/^[a-z][a-z0-9_]*$/.test(name)) {
+        throw new Error(`${source} tool name must match /^[a-z][a-z0-9_]*$/`);
+    }
+    if (typeof description !== "string") {
+        throw new Error(`${source} tool description must be a string`);
+    }
+    const normalizedInputSchema = await normalizeInputSchema(inputSchema, source, toolPath);
+    if (!Array.isArray(capabilities) ||
+        !capabilities.every((capability) => typeof capability === "string")) {
+        throw new Error(`${source} capabilities must be an array of strings`);
+    }
+    if (!isRecord(approval) || typeof approval.required !== "boolean") {
+        throw new Error(`${source} approval must declare a required boolean`);
+    }
+    if (!isToolHandler(handler)) {
+        throw new Error(`${source} handler must be a function`);
+    }
+    return {
+        source,
+        name,
+        description,
+        inputSchema: normalizedInputSchema.jsonSchema,
+        async validateInput(input) {
+            const result = await normalizedInputSchema.parse(input);
+            return result.success ? undefined : result.error;
+        },
+        parseInput: normalizedInputSchema.parse,
+        capabilities,
+        approval: {
+            required: approval.required,
+            ...(typeof approval.reason === "string" ? { reason: approval.reason } : {}),
+        },
+        handler,
+    };
+}
+function isToolHandler(value) {
+    return typeof value === "function";
+}

package/dist/tools/schema.d.ts

@@ -0,0 +1,7 @@
+import type { JsonSchema, ToolInputParseResult } from "../types/index.js";
+export interface NormalizedInputSchema {
+    jsonSchema: JsonSchema;
+    parse(value: unknown): Promise<ToolInputParseResult>;
+}
+export declare function normalizeInputSchema(value: unknown, source: string, toolPath: string): Promise<NormalizedInputSchema>;
+export declare function isJsonSchema(value: unknown): value is JsonSchema;

package/dist/tools/schema.js

@@ -0,0 +1,101 @@
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { Ajv } from "ajv";
+import { zodToJsonSchema } from "zod-to-json-schema";
+const ajv = new Ajv({ allErrors: true, strict: false });
+const addFormats = createRequire(import.meta.url)("ajv-formats");
+addFormats(ajv);
+export async function normalizeInputSchema(value, source, toolPath) {
+    if (isZodSchema(value)) {
+        return {
+            jsonSchema: await convertZodSchema(value, source, toolPath),
+            async parse(input) {
+                const result = await value.safeParseAsync(input);
+                if (result.success)
+                    return { success: true, value: result.data };
+                return {
+                    success: false,
+                    error: result.error.issues
+                        .map((issue) => `${issue.path.join(".") || "input"}: ${issue.message}`)
+                        .join("; "),
+                };
+            },
+        };
+    }
+    if (!isJsonSchema(value)) {
+        throw new Error(`${source} inputSchema must be a Zod schema or JSON Schema`);
+    }
+    let validator;
+    try {
+        validator = ajv.compile(value);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${source} inputSchema is not a valid JSON Schema: ${message}`);
+    }
+    return {
+        jsonSchema: value,
+        async parse(input) {
+            const error = validateJsonSchemaWithAjv(input, validator);
+            return error ? { success: false, error } : { success: true, value: input };
+        },
+    };
+}
+export function isJsonSchema(value) {
+    return typeof value === "boolean" || isJsonObject(value);
+}
+function validateJsonSchemaWithAjv(value, validator) {
+    if (validator(value))
+        return undefined;
+    const issues = validator.errors?.map(formatAjvIssue) ?? [];
+    return issues.length === 0 ? "input does not match the schema" : issues.join("; ");
+}
+function formatAjvIssue(issue) {
+    const path = jsonPointerPath(issue.instancePath);
+    if (issue.keyword === "required") {
+        const property = issue.params.missingProperty;
+        return `${location(path ? `${path}.${property}` : property)}missing required property ${property}`;
+    }
+    if (issue.keyword === "additionalProperties") {
+        const property = issue.params.additionalProperty;
+        return `${location(path ? `${path}.${property}` : property)}unknown property ${property}`;
+    }
+    if (issue.keyword === "type") {
+        return `${location(path)}expected ${issue.params.type}`;
+    }
+    return `${location(path)}${issue.message ?? "invalid"}`;
+}
+function location(path) {
+    return path ? `${path}: ` : "";
+}
+function jsonPointerPath(instancePath) {
+    return instancePath
+        .split("/")
+        .slice(1)
+        .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"))
+        .join(".");
+}
+async function convertZodSchema(schema, source, toolPath) {
+    if (!isJsonObject(schema) || !("_zod" in schema)) {
+        return zodToJsonSchema(schema);
+    }
+    try {
+        const requireFromTool = createRequire(toolPath);
+        const zodV4ModulePath = requireFromTool.resolve("zod/v4");
+        const zodV4 = (await import(pathToFileURL(zodV4ModulePath).href));
+        if (typeof zodV4.toJSONSchema !== "function") {
+            throw new Error("The installed Zod v4 package does not export toJSONSchema");
+        }
+        return zodV4.toJSONSchema(schema, { target: "draft-7" });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`${source} could not convert its Zod 4 schema to JSON Schema: ${message}`);
+    }
+}
+function isJsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isZodSchema(value) {
+    return isJsonObject(value) && typeof value.safeParseAsync === "function";
+}

package/dist/tools/skill-model-tool.d.ts

@@ -0,0 +1,7 @@
+import { type Skill } from "@plico-ai/core";
+import type { DeclaredTool } from "../types/index.js";
+/**
+ * The tool that returns a skill's full text. It can only return a skill that `skills/` declared when
+ * the run started, so a name never reaches outside that folder.
+ */
+export declare function createSkillModelTool(skills: Skill[]): Promise<DeclaredTool>;

package/dist/tools/skill-model-tool.js

@@ -0,0 +1,38 @@
+import { SKILL_TOOL_NAME } from "@plico-ai/core";
+import { normalizeInputSchema } from "./schema.js";
+const source = "plico:skills";
+/**
+ * The tool that returns a skill's full text. It can only return a skill that `skills/` declared when
+ * the run started, so a name never reaches outside that folder.
+ */
+export async function createSkillModelTool(skills) {
+    const byName = new Map(skills.map((skill) => [skill.name, skill]));
+    const schema = await normalizeInputSchema({
+        type: "object",
+        properties: { name: { type: "string", minLength: 1, maxLength: 256 } },
+        required: ["name"],
+        additionalProperties: false,
+    }, source, source);
+    return {
+        name: SKILL_TOOL_NAME,
+        description: "Load the full instructions of one skill from the Skills list in your instructions, by name.",
+        capabilities: [],
+        approval: { required: false },
+        source,
+        inputSchema: schema.jsonSchema,
+        validateInput: async (input) => {
+            const result = await schema.parse(input);
+            return result.success ? undefined : result.error;
+        },
+        parseInput: schema.parse,
+        handler: async (input) => {
+            const name = input.name;
+            const skill = byName.get(name);
+            if (!skill)
+                return {
+                    error: `Unknown skill: ${name}. Available skills: ${[...byName.keys()].join(", ")}.`,
+                };
+            return { name: skill.name, content: skill.body };
+        },
+    };
+}

package/dist/types/artifacts.d.ts

@@ -0,0 +1,5 @@
+export interface ArtifactFileInput {
+    path: string;
+    content: string;
+    mimeType?: string;
+}

package/dist/types/artifacts.js

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

package/dist/types/evals.d.ts

@@ -0,0 +1,16 @@
+import type { RunStatus } from "@plico-ai/contracts";
+import type { DryRunScriptStep } from "./script.js";
+import type { EventStore } from "./store.js";
+export interface EvalExpectation {
+    status?: RunStatus;
+    outputContains?: string;
+}
+export interface EvalCase {
+    name: string;
+    description?: string;
+    script: DryRunScriptStep[];
+    expect?: EvalExpectation;
+}
+export interface RunEvalsOptions {
+    eventStore?: EventStore;
+}

package/dist/types/evals.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+import type { ArtifactContent, ArtifactFile, ArtifactFileMetadata, ArtifactSnapshot, ArtifactSnapshotDetail, ArtifactVersion, ArtifactWorkspace, ComposedInstructions, DiagnosticSeverity, EvalCaseResult, EvalReport, EvalSummary, PlicoEvent, PlicoEventType, ReadinessDiagnostic, ReadinessReport, RunResult, RunStatus, RunSummary } from "@plico-ai/contracts";
+export type { ArtifactFileInput } from "./artifacts.js";
+export type { EvalCase, EvalExpectation, RunEvalsOptions } from "./evals.js";
+export type { ModelChunk, ModelProvider, ModelRequest, ModelResponse, ModelToolCall, ProviderMessage, } from "./provider.js";
+export type { ReadinessOptions } from "./readiness.js";
+export type { RunProjectOptions } from "./run.js";
+export type { DryRunScriptStep } from "./script.js";
+export type { CreateSqliteEventStoreOptions, EventStore } from "./store.js";
+export type { DeclaredTool, JsonSchema, ToolApprovalPolicy, ToolArtifactContext, ToolArtifactFile, ToolDefinition, ToolHandlerContext, ToolInputParseResult, ToolInputSchema, ZodInputParseResult, ZodInputSchema, } from "./tools.js";
+export type { ArtifactContent, ArtifactFile, ArtifactFileMetadata, ArtifactSnapshot, ArtifactSnapshotDetail, ArtifactVersion, ArtifactWorkspace, ComposedInstructions, DiagnosticSeverity, EvalCaseResult, EvalReport, EvalSummary, PlicoEvent, PlicoEventType, ReadinessDiagnostic, ReadinessReport, RunResult, RunStatus, RunSummary, };

package/dist/types/index.js

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

package/dist/types/provider.d.ts

@@ -0,0 +1,45 @@
+import type { JsonValue, ModelToolCall } from "@plico-ai/contracts";
+import type { JsonSchema } from "./tools.js";
+export interface ProviderMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    toolCallId?: string;
+    toolName?: string;
+    toolCalls?: ModelToolCall[];
+    providerMetadata?: JsonValue;
+}
+export type { ModelToolCall } from "@plico-ai/contracts";
+export interface ModelRequest {
+    messages: ProviderMessage[];
+    maxSteps: number;
+    tools?: Array<{
+        name: string;
+        description: string;
+        inputSchema: JsonSchema;
+    }>;
+}
+export interface ModelResponse {
+    providerMetadata?: JsonValue;
+    content: string;
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    toolCalls?: ModelToolCall[];
+}
+export type ModelChunk = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool.call";
+    call: ModelToolCall;
+} | {
+    type: "finish";
+    usage: ModelResponse["usage"];
+    providerMetadata?: JsonValue;
+};
+export interface ModelProvider {
+    stream(request: ModelRequest, options: {
+        signal: AbortSignal;
+    }): AsyncIterable<ModelChunk>;
+}

package/dist/types/provider.js

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

package/dist/types/readiness.d.ts

@@ -0,0 +1,9 @@
+import type { ThreadStore } from "../storage/sqlite/threads.js";
+import type { EventStore } from "./store.js";
+export interface ReadinessOptions {
+    databasePath?: string;
+    eventStore?: EventStore;
+    threadStore?: Pick<ThreadStore, "storageIdentity">;
+    /** Built Studio directory. Omit when Studio is not in use. */
+    studioPath?: string | undefined;
+}

package/dist/types/readiness.js

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

package/dist/types/run.d.ts

@@ -0,0 +1,28 @@
+import type { JsonValue } from "@plico-ai/contracts";
+import type { Engine } from "../engine/index.js";
+import type { ModelProvider, ProviderMessage } from "./provider.js";
+import type { DryRunScriptStep } from "./script.js";
+import type { EventStore } from "./store.js";
+export interface RunProjectOptions {
+    script?: DryRunScriptStep[];
+    /**
+     * Do not run tool handlers for scripted `tool.call` steps. Each step supplies its output as
+     * `result`; a step without one fails the run, and `live: true` opts a step back in to its handler.
+     */
+    mockTools?: boolean;
+    eventStore?: EventStore;
+    /** Runs the loop durably. Defaults to an in-memory engine that does not survive the process. */
+    engine?: Engine;
+    runId?: string;
+    provider?: ModelProvider;
+    /** Opaque identity used to prevent recovery with a different provider configuration. */
+    providerRecoveryKey?: string;
+    message?: string;
+    threadId?: string;
+    /** Host data stamped on `run.started`. Immutable and returned by run reads and filters. */
+    metadata?: Record<string, JsonValue>;
+    /** Host data passed to tools as `ctx.context` and recorded on `run.started`. No secrets. */
+    context?: Record<string, JsonValue>;
+    history?: Array<Pick<ProviderMessage, "role" | "content">>;
+    onStarted?: (runId: string) => void;
+}

package/dist/types/run.js

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

package/dist/types/script.d.ts

@@ -0,0 +1,16 @@
+import type { ArtifactFileInput } from "./artifacts.js";
+export type DryRunScriptStep = {
+    type: "assistant.output";
+    content: string;
+} | {
+    type: "tool.call";
+    toolName: string;
+    arguments: unknown;
+    /** The output to use instead of running the tool, when the run mocks tools. */
+    result?: unknown;
+    /** Run the real handler even when the run mocks tools. */
+    live?: true;
+} | {
+    type: "artifact.write";
+    files: ArtifactFileInput[];
+};

package/dist/types/script.js

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

package/dist/types/store.d.ts

@@ -0,0 +1,24 @@
+import type { EvalReport, JsonValue, PlicoEvent, RunSummary } from "@plico-ai/contracts";
+export interface EventStore {
+    readonly storageIdentity?: string;
+    appendEvent(event: PlicoEvent): Promise<void>;
+    /** Lists runs, newest first. `metadata` keeps runs whose top-level keys equal every given value. */
+    listRuns(filter?: {
+        metadata?: Record<string, JsonValue>;
+    }): Promise<RunSummary[]>;
+    getRun(runId: string): Promise<RunSummary | undefined>;
+    getEvents(runId: string, options?: {
+        afterSequence?: number;
+    }): Promise<PlicoEvent[]>;
+    /** Returns run events in a thread, ordered by their durable insertion order. */
+    getThreadRunEvents?(threadId: string): Promise<PlicoEvent[]>;
+    /** Returns thread run events through the selected run's final durable position. */
+    getThreadRunEventsThrough?(threadId: string, runId: string): Promise<PlicoEvent[]>;
+    persistEvalReport(report: EvalReport): Promise<void>;
+    getLatestEvalReport(): Promise<EvalReport | undefined>;
+}
+export interface CreateSqliteEventStoreOptions {
+    databasePath: string;
+    /** Open an existing database without changing it. Adds no files unless it has a pending WAL. */
+    readOnly?: boolean;
+}

package/dist/types/store.js

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

package/dist/types/tools.d.ts

@@ -0,0 +1,15 @@
+import type { JsonSchema, ToolDefinition } from "@plico-ai/contracts";
+export type { JsonSchema, JsonSchemaObject, ToolApprovalPolicy, ToolArtifactContext, ToolArtifactFile, ToolDefinition, ToolHandlerContext, ToolInputSchema, ZodInputParseResult, ZodInputSchema, } from "@plico-ai/contracts";
+export type ToolInputParseResult = {
+    success: true;
+    value: unknown;
+} | {
+    success: false;
+    error: string;
+};
+export interface DeclaredTool extends Omit<ToolDefinition, "inputSchema"> {
+    source: string;
+    inputSchema: JsonSchema;
+    validateInput(input: unknown): Promise<string | undefined>;
+    parseInput(input: unknown): Promise<ToolInputParseResult>;
+}