@plico-ai/runtime 0.0.0-reserved.0 → 0.1.0

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

@@ -0,0 +1,124 @@
+import mime from "mime";
+import picomatch from "picomatch";
+import { validateArtifactPath } from "../run/artifact-tool-context.js";
+const defaultListLimit = 100;
+const defaultReadLimit = 200;
+const maxReadBytes = 32 * 1024;
+export async function listFiles(input, artifacts) {
+    const value = input;
+    const offset = value.offset ?? 0;
+    const limit = value.limit ?? defaultListLimit;
+    let matches = await artifacts.list();
+    if (value.glob !== undefined) {
+        let match;
+        try {
+            match = picomatch(value.glob, { strictBrackets: true, maxLength: 1024, dot: true });
+        }
+        catch (error) {
+            throw new Error(`Invalid file glob: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        matches = matches.filter((file) => match(file.path));
+    }
+    matches.sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
+    const files = matches
+        .slice(offset, offset + limit)
+        .map(({ path, sizeBytes, mimeType, version }) => ({
+        path,
+        sizeBytes,
+        mimeType,
+        version,
+    }));
+    const nextOffset = offset + files.length;
+    return {
+        files,
+        offset,
+        ...(nextOffset < matches.length ? { nextOffset } : {}),
+    };
+}
+export async function readFile(input, artifacts) {
+    const value = input;
+    validateArtifactPath(value.path);
+    const file = await artifacts.read(value.path);
+    if (!file)
+        throw new Error(`Artifact not found: ${value.path}`);
+    if (file.content instanceof Uint8Array)
+        return { ...metadata(file), path: file.path, binary: true };
+    const lines = file.content.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    const offset = value.offset ?? 1;
+    const limit = value.limit ?? defaultReadLimit;
+    const start = offset - 1;
+    const page = [];
+    let pageBytes = 0;
+    for (let index = start; index < Math.min(lines.length, start + limit); index++) {
+        const line = lines[index] ?? "";
+        const lineBytes = Buffer.byteLength(line, "utf8");
+        if (pageBytes + lineBytes > maxReadBytes) {
+            if (page.length === 0)
+                throw new Error(`Line ${index + 1} of ${value.path} exceeds the 32 KiB read limit.`);
+            break;
+        }
+        page.push(line);
+        pageBytes += lineBytes;
+    }
+    const nextOffset = start + page.length + 1;
+    return {
+        path: file.path,
+        content: page.join(""),
+        mimeType: file.mimeType,
+        version: file.version,
+        offset,
+        ...(nextOffset <= lines.length ? { nextOffset } : {}),
+    };
+}
+export async function writeFile(input, artifacts) {
+    const value = input;
+    const mimeType = value.mimeType ?? mime.getType(value.path) ?? "text/plain";
+    return artifacts.write(value.path, value.content, { mimeType });
+}
+export async function editFile(input, artifacts) {
+    const value = input;
+    if (value.old === value.new)
+        throw new Error("The old and new text are identical; no edit was made.");
+    validateArtifactPath(value.path);
+    const file = await artifacts.read(value.path);
+    if (!file)
+        throw new Error(`Artifact not found: ${value.path}`);
+    if (file.content instanceof Uint8Array)
+        throw new Error(`Cannot edit binary artifact ${value.path}; edit_file accepts text only.`);
+    const occurrences = countMatches(file.content, value.old);
+    if (occurrences === 0)
+        throw new Error(`Text to replace was not found in ${value.path}.`);
+    if (occurrences > 1 && value.replaceAll !== true)
+        throw new Error(`Text to replace occurs ${occurrences} times in ${value.path}; set replaceAll to true.`);
+    const content = value.replaceAll
+        ? file.content.replaceAll(value.old, () => value.new)
+        : replaceFirst(file.content, value.old, value.new);
+    const write = await artifacts.write(value.path, content, { mimeType: file.mimeType });
+    return { ...write, replacementCount: value.replaceAll ? occurrences : 1 };
+}
+function metadata(file) {
+    return {
+        path: file.path,
+        sizeBytes: file.content instanceof Uint8Array
+            ? file.content.byteLength
+            : Buffer.byteLength(file.content, "utf8"),
+        mimeType: file.mimeType,
+        version: file.version,
+        contentHash: file.contentHash,
+    };
+}
+function countMatches(content, search) {
+    let count = 0;
+    let offset = 0;
+    while (true) {
+        const index = content.indexOf(search, offset);
+        if (index < 0)
+            return count;
+        count++;
+        offset = index + search.length;
+    }
+}
+function replaceFirst(content, search, replacement) {
+    const index = content.indexOf(search);
+    return `${content.slice(0, index)}${replacement}${content.slice(index + search.length)}`;
+}

package/dist/tools/artifact-model-tools.d.ts

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

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>;
+}