@perstack/core 0.0.52 → 0.0.54

package/dist/src/schemas/expert.d.ts

@@ -0,0 +1,309 @@
+import { z } from "zod";
+import type { AnthropicProviderSkill, ProviderToolOptions } from "./provider-tools.js";
+import type { RuntimeVersion } from "./runtime-version.js";
+import type { Skill } from "./skill.js";
+/**
+ * An Expert definition - an AI agent with specific skills and instructions.
+ * Experts can delegate to other Experts and use MCP tools.
+ */
+export interface Expert {
+    /** Unique key identifying this Expert (e.g., "my-expert" or "my-expert@1.0.0") */
+    key: string;
+    /** Display name for the Expert */
+    name: string;
+    /** Semantic version string */
+    version: string;
+    /** Human-readable description of what this Expert does */
+    description?: string;
+    /** System instruction defining the Expert's behavior */
+    instruction: string;
+    /** Map of skill name to skill configuration */
+    skills: Record<string, Skill>;
+    /** List of Expert keys this Expert can delegate to */
+    delegates: string[];
+    /** Tags for categorization and discovery */
+    tags: string[];
+    /** Minimum runtime version required to run this Expert */
+    minRuntimeVersion: RuntimeVersion;
+    /** Provider-specific tool names to enable (e.g., "webSearch", "codeExecution") */
+    providerTools?: string[];
+    /** Anthropic Agent Skills configuration */
+    providerSkills?: AnthropicProviderSkill[];
+    /** Provider tool options (e.g., webSearch maxUses, allowedDomains) */
+    providerToolOptions?: ProviderToolOptions;
+}
+/**
+ * Base object schema for Expert. Use this for `.omit()` / `.pick()` operations.
+ * For parsing with delegation validation, use `expertSchema` instead.
+ */
+export declare const expertBaseSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    instruction: z.ZodString;
+    skills: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"mcpStdioSkill">;
+        description: z.ZodOptional<z.ZodString>;
+        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        rule: z.ZodOptional<z.ZodString>;
+        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        command: z.ZodString;
+        packageName: z.ZodOptional<z.ZodString>;
+        requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"mcpSseSkill">;
+        description: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        endpoint: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"interactiveSkill">;
+        description: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            inputJsonSchema: z.ZodString;
+        }, z.core.$strip>>, z.ZodTransform<{
+            [k: string]: {
+                name: string;
+                inputJsonSchema: string;
+                description?: string | undefined;
+            };
+        }, Record<string, {
+            inputJsonSchema: string;
+            description?: string | undefined;
+        }>>>;
+    }, z.core.$strip>], "type">>>>, z.ZodTransform<{
+        [k: string]: {
+            type: "mcpStdioSkill";
+            name: string;
+            pick: string[];
+            omit: string[];
+            command: string;
+            args: string[];
+            requiredEnv: string[];
+            description?: string | undefined;
+            rule?: string | undefined;
+            packageName?: string | undefined;
+        } | {
+            type: "mcpSseSkill";
+            name: string;
+            pick: string[];
+            omit: string[];
+            endpoint: string;
+            description?: string | undefined;
+            rule?: string | undefined;
+        } | {
+            type: "interactiveSkill";
+            name: string;
+            tools: {
+                [k: string]: {
+                    name: string;
+                    inputJsonSchema: string;
+                    description?: string | undefined;
+                };
+            };
+            description?: string | undefined;
+            rule?: string | undefined;
+        };
+    }, Record<string, {
+        type: "mcpStdioSkill";
+        args: string[];
+        pick: string[];
+        omit: string[];
+        command: string;
+        requiredEnv: string[];
+        description?: string | undefined;
+        rule?: string | undefined;
+        packageName?: string | undefined;
+    } | {
+        type: "mcpSseSkill";
+        pick: string[];
+        omit: string[];
+        endpoint: string;
+        description?: string | undefined;
+        rule?: string | undefined;
+    } | {
+        type: "interactiveSkill";
+        tools: {
+            [k: string]: {
+                name: string;
+                inputJsonSchema: string;
+                description?: string | undefined;
+            };
+        };
+        description?: string | undefined;
+        rule?: string | undefined;
+    }>>>;
+    delegates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    minRuntimeVersion: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>>;
+    providerTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    providerSkills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"builtin">;
+        skillId: z.ZodEnum<{
+            pdf: "pdf";
+            docx: "docx";
+            pptx: "pptx";
+            xlsx: "xlsx";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        name: z.ZodString;
+        definition: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    providerToolOptions: z.ZodOptional<z.ZodObject<{
+        webSearch: z.ZodOptional<z.ZodObject<{
+            maxUses: z.ZodOptional<z.ZodNumber>;
+            allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        webFetch: z.ZodOptional<z.ZodObject<{
+            maxUses: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        fileSearch: z.ZodOptional<z.ZodObject<{
+            vectorStoreIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            maxNumResults: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Expert schema with delegation rule validation.
+ * Rejects self-delegation, out-of-scope delegates, and delegate-to-own-coordinator.
+ */
+export declare const expertSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    instruction: z.ZodString;
+    skills: z.ZodPipe<z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"mcpStdioSkill">;
+        description: z.ZodOptional<z.ZodString>;
+        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        rule: z.ZodOptional<z.ZodString>;
+        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        command: z.ZodString;
+        packageName: z.ZodOptional<z.ZodString>;
+        requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"mcpSseSkill">;
+        description: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        endpoint: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"interactiveSkill">;
+        description: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            inputJsonSchema: z.ZodString;
+        }, z.core.$strip>>, z.ZodTransform<{
+            [k: string]: {
+                name: string;
+                inputJsonSchema: string;
+                description?: string | undefined;
+            };
+        }, Record<string, {
+            inputJsonSchema: string;
+            description?: string | undefined;
+        }>>>;
+    }, z.core.$strip>], "type">>>>, z.ZodTransform<{
+        [k: string]: {
+            type: "mcpStdioSkill";
+            name: string;
+            pick: string[];
+            omit: string[];
+            command: string;
+            args: string[];
+            requiredEnv: string[];
+            description?: string | undefined;
+            rule?: string | undefined;
+            packageName?: string | undefined;
+        } | {
+            type: "mcpSseSkill";
+            name: string;
+            pick: string[];
+            omit: string[];
+            endpoint: string;
+            description?: string | undefined;
+            rule?: string | undefined;
+        } | {
+            type: "interactiveSkill";
+            name: string;
+            tools: {
+                [k: string]: {
+                    name: string;
+                    inputJsonSchema: string;
+                    description?: string | undefined;
+                };
+            };
+            description?: string | undefined;
+            rule?: string | undefined;
+        };
+    }, Record<string, {
+        type: "mcpStdioSkill";
+        args: string[];
+        pick: string[];
+        omit: string[];
+        command: string;
+        requiredEnv: string[];
+        description?: string | undefined;
+        rule?: string | undefined;
+        packageName?: string | undefined;
+    } | {
+        type: "mcpSseSkill";
+        pick: string[];
+        omit: string[];
+        endpoint: string;
+        description?: string | undefined;
+        rule?: string | undefined;
+    } | {
+        type: "interactiveSkill";
+        tools: {
+            [k: string]: {
+                name: string;
+                inputJsonSchema: string;
+                description?: string | undefined;
+            };
+        };
+        description?: string | undefined;
+        rule?: string | undefined;
+    }>>>;
+    delegates: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    minRuntimeVersion: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>>;
+    providerTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    providerSkills: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"builtin">;
+        skillId: z.ZodEnum<{
+            pdf: "pdf";
+            docx: "docx";
+            pptx: "pptx";
+            xlsx: "xlsx";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        name: z.ZodString;
+        definition: z.ZodString;
+    }, z.core.$strip>], "type">>>;
+    providerToolOptions: z.ZodOptional<z.ZodObject<{
+        webSearch: z.ZodOptional<z.ZodObject<{
+            maxUses: z.ZodOptional<z.ZodNumber>;
+            allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        webFetch: z.ZodOptional<z.ZodObject<{
+            maxUses: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        fileSearch: z.ZodOptional<z.ZodObject<{
+            vectorStoreIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            maxNumResults: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=expert.d.ts.map

package/dist/src/schemas/expert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expert.d.ts","sourceRoot":"","sources":["../../../src/schemas/expert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AASvB,OAAO,KAAK,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEtF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAgD,KAAK,EAAE,MAAM,YAAY,CAAA;AAGrF;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,kFAAkF;IAClF,GAAG,EAAE,MAAM,CAAA;IACX,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,0DAA0D;IAC1D,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC7B,sDAAsD;IACtD,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,4CAA4C;IAC5C,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,0DAA0D;IAC1D,iBAAiB,EAAE,cAAc,CAAA;IACjC,kFAAkF;IAClF,aAAa,CAAC,EAAE,MAAM,EAAE,CAAA;IACxB,2CAA2C;IAC3C,cAAc,CAAC,EAAE,sBAAsB,EAAE,CAAA;IACzC,sEAAsE;IACtE,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;CAC1C;AAOD;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqD3B,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKvB,CAAA"}

package/dist/src/schemas/expert.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { expertKeyRegex, expertNameRegex, expertVersionRegex, maxExpertNameLength, tagNameRegex, } from "../constants/constants.js";
+import { validateAllDelegations } from "../utils/expert-type.js";
+import { anthropicProviderSkillSchema, providerToolOptionsSchema } from "./provider-tools.js";
+import { runtimeVersionSchema } from "./runtime-version.js";
+import { interactiveSkillSchema, mcpSseSkillSchema, mcpStdioSkillSchema } from "./skill.js";
+/**
+ * Base object schema for Expert. Use this for `.omit()` / `.pick()` operations.
+ * For parsing with delegation validation, use `expertSchema` instead.
+ */
+export const expertBaseSchema = z.object({
+    key: z.string().regex(expertKeyRegex).min(1),
+    name: z.string().regex(expertNameRegex).min(1).max(maxExpertNameLength),
+    version: z.string().regex(expertVersionRegex),
+    description: z
+        .string()
+        .max(1024 * 2)
+        .optional(),
+    instruction: z
+        .string()
+        .min(1)
+        .max(1024 * 20),
+    skills: z
+        .record(z.string(), z.discriminatedUnion("type", [
+        mcpStdioSkillSchema.omit({ name: true }),
+        mcpSseSkillSchema.omit({ name: true }),
+        interactiveSkillSchema.omit({ name: true }),
+    ]))
+        .optional()
+        .default({
+        "@perstack/base": {
+            type: "mcpStdioSkill",
+            description: "Base skill",
+            command: "npx",
+            args: ["-y", "@perstack/base"],
+            pick: [],
+            omit: [],
+            requiredEnv: [],
+        },
+    })
+        .transform((skills) => {
+        return Object.fromEntries(Object.entries(skills).map(([key, skillWithoutName]) => [
+            key,
+            z
+                .discriminatedUnion("type", [
+                mcpStdioSkillSchema,
+                mcpSseSkillSchema,
+                interactiveSkillSchema,
+            ])
+                .parse({ ...skillWithoutName, name: key }),
+        ]));
+    }),
+    delegates: z.array(z.string().regex(expertKeyRegex).min(1)).optional().default([]),
+    tags: z.array(z.string().regex(tagNameRegex).min(1)).optional().default([]),
+    minRuntimeVersion: runtimeVersionSchema.default("v1.0"),
+    providerTools: z.array(z.string()).optional(),
+    providerSkills: z.array(anthropicProviderSkillSchema).optional(),
+    providerToolOptions: providerToolOptionsSchema,
+});
+/**
+ * Expert schema with delegation rule validation.
+ * Rejects self-delegation, out-of-scope delegates, and delegate-to-own-coordinator.
+ */
+export const expertSchema = expertBaseSchema.superRefine((data, ctx) => {
+    const errors = validateAllDelegations(data.key, data.delegates);
+    for (const error of errors) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: error, path: ["delegates"] });
+    }
+});
+//# sourceMappingURL=expert.js.map

package/dist/src/schemas/expert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expert.js","sourceRoot":"","sources":["../../../src/schemas/expert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EACL,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,YAAY,GACb,MAAM,2BAA2B,CAAA;AAClC,OAAO,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAA;AAEhE,OAAO,EAAE,4BAA4B,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAE7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAE3D,OAAO,EAAE,sBAAsB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAsC3F;;;GAGG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,mBAAmB,CAAC;IACvE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,kBAAkB,CAAC;IAC7C,WAAW,EAAE,CAAC;SACX,MAAM,EAAE;SACR,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC;SACb,QAAQ,EAAE;IACb,WAAW,EAAE,CAAC;SACX,MAAM,EAAE;SACR,GAAG,CAAC,CAAC,CAAC;SACN,GAAG,CAAC,IAAI,GAAG,EAAE,CAAC;IACjB,MAAM,EAAE,CAAC;SACN,MAAM,CACL,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,kBAAkB,CAAC,MAAM,EAAE;QAC3B,mBAAmB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACxC,iBAAiB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACtC,sBAAsB,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;KAC5C,CAAC,CACH;SACA,QAAQ,EAAE;SACV,OAAO,CAAC;QACP,gBAAgB,EAAE;YAChB,IAAI,EAAE,eAAe;YACrB,WAAW,EAAE,YAAY;YACzB,OAAO,EAAE,KAAK;YACd,IAAI,EAAE,CAAC,IAAI,EAAE,gBAAgB,CAAC;YAC9B,IAAI,EAAE,EAAE;YACR,IAAI,EAAE,EAAE;YACR,WAAW,EAAE,EAAE;SACW;KAC7B,CAAC;SACD,SAAS,CAAC,CAAC,MAAM,EAAE,EAAE;QACpB,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,gBAAgB,CAAC,EAAE,EAAE,CAAC;YACtD,GAAG;YACH,CAAC;iBACE,kBAAkB,CAAC,MAAM,EAAE;gBAC1B,mBAAmB;gBACnB,iBAAiB;gBACjB,sBAAsB;aACvB,CAAC;iBACD,KAAK,CAAC,EAAE,GAAG,gBAAgB,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC;SAC7C,CAAC,CACH,CAAA;IACH,CAAC,CAAC;IACJ,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAClF,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;IAC3E,iBAAiB,EAAE,oBAAoB,CAAC,OAAO,CAAC,MAAM,CAAC;IACvD,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IAC7C,cAAc,EAAE,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC,QAAQ,EAAE;IAChE,mBAAmB,EAAE,yBAAyB;CAC/C,CAAC,CAAA;AAEF;;;GAGG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,gBAAgB,CAAC,WAAW,CAAC,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;IACrE,MAAM,MAAM,GAAG,sBAAsB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;IAC/D,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,GAAG,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAA;IACpF,CAAC;AACH,CAAC,CAAC,CAAA"}

package/dist/src/schemas/job.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import type { RuntimeVersion } from "./runtime-version.js";
+import type { Usage } from "./usage.js";
+export type JobStatus = "running" | "completed" | "stoppedByInteractiveTool" | "stoppedByError" | "stoppedByCancellation";
+export declare const jobStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    stoppedByInteractiveTool: "stoppedByInteractiveTool";
+    stoppedByError: "stoppedByError";
+    stoppedByCancellation: "stoppedByCancellation";
+    running: "running";
+}>;
+export interface Job {
+    id: string;
+    status: JobStatus;
+    coordinatorExpertKey: string;
+    runtimeVersion: RuntimeVersion;
+    totalSteps: number;
+    usage: Usage;
+    startedAt: number;
+    finishedAt?: number;
+}
+export declare const jobSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        stoppedByInteractiveTool: "stoppedByInteractiveTool";
+        stoppedByError: "stoppedByError";
+        stoppedByCancellation: "stoppedByCancellation";
+        running: "running";
+    }>;
+    coordinatorExpertKey: z.ZodString;
+    runtimeVersion: z.ZodPipe<z.ZodString, z.ZodTransform<`v${number}.${number}`, string>>;
+    totalSteps: z.ZodNumber;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        cachedInputTokens: z.ZodNumber;
+    }, z.core.$strip>;
+    startedAt: z.ZodNumber;
+    finishedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+//# sourceMappingURL=job.d.ts.map

package/dist/src/schemas/job.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.d.ts","sourceRoot":"","sources":["../../../src/schemas/job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAGvC,MAAM,MAAM,SAAS,GACjB,SAAS,GACT,WAAW,GACX,0BAA0B,GAC1B,gBAAgB,GAChB,uBAAuB,CAAA;AAE3B,eAAO,MAAM,eAAe;;;;;;EAM1B,CAAA;AAEF,MAAM,WAAW,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,SAAS,CAAA;IACjB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,cAAc,EAAE,cAAc,CAAA;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE,KAAK,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;iBASpB,CAAA"}

package/dist/src/schemas/job.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { runtimeVersionSchema } from "./runtime-version.js";
+import { usageSchema } from "./usage.js";
+export const jobStatusSchema = z.enum([
+    "running",
+    "completed",
+    "stoppedByInteractiveTool",
+    "stoppedByError",
+    "stoppedByCancellation",
+]);
+export const jobSchema = z.object({
+    id: z.string(),
+    status: jobStatusSchema,
+    coordinatorExpertKey: z.string(),
+    runtimeVersion: runtimeVersionSchema,
+    totalSteps: z.number(),
+    usage: usageSchema,
+    startedAt: z.number(),
+    finishedAt: z.number().optional(),
+});
+jobSchema;
+//# sourceMappingURL=job.js.map

package/dist/src/schemas/job.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"job.js","sourceRoot":"","sources":["../../../src/schemas/job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAE3D,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AASxC,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,IAAI,CAAC;IACpC,SAAS;IACT,WAAW;IACX,0BAA0B;IAC1B,gBAAgB;IAChB,uBAAuB;CACxB,CAAC,CAAA;AAaF,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC;IAChC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE;IACd,MAAM,EAAE,eAAe;IACvB,oBAAoB,EAAE,CAAC,CAAC,MAAM,EAAE;IAChC,cAAc,EAAE,oBAAoB;IACpC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,KAAK,EAAE,WAAW;IAClB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAA;AACF,SAAkC,CAAA"}

package/dist/src/schemas/lockfile.d.ts

@@ -0,0 +1,143 @@
+import { z } from "zod";
+import type { Skill } from "./skill.js";
+export interface LockfileToolDefinition {
+    skillName: string;
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export declare const lockfileToolDefinitionSchema: z.ZodObject<{
+    skillName: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export interface LockfileExpert {
+    key: string;
+    name: string;
+    version: string;
+    description?: string;
+    instruction: string;
+    skills: Record<string, Skill>;
+    delegates: string[];
+    tags: string[];
+    toolDefinitions: LockfileToolDefinition[];
+}
+export declare const lockfileExpertSchema: z.ZodObject<{
+    key: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    instruction: z.ZodString;
+    skills: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"mcpStdioSkill">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        command: z.ZodString;
+        packageName: z.ZodOptional<z.ZodString>;
+        args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"mcpSseSkill">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        endpoint: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"interactiveSkill">;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        rule: z.ZodOptional<z.ZodString>;
+        tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            inputJsonSchema: z.ZodString;
+        }, z.core.$strip>>, z.ZodTransform<{
+            [k: string]: {
+                name: string;
+                inputJsonSchema: string;
+                description?: string | undefined;
+            };
+        }, Record<string, {
+            inputJsonSchema: string;
+            description?: string | undefined;
+        }>>>;
+    }, z.core.$strip>], "type">>;
+    delegates: z.ZodArray<z.ZodString>;
+    tags: z.ZodArray<z.ZodString>;
+    toolDefinitions: z.ZodArray<z.ZodObject<{
+        skillName: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface Lockfile {
+    version: "1";
+    generatedAt: number;
+    configPath: string;
+    experts: Record<string, LockfileExpert>;
+}
+export declare const lockfileSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    generatedAt: z.ZodNumber;
+    configPath: z.ZodString;
+    experts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        key: z.ZodString;
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        instruction: z.ZodString;
+        skills: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"mcpStdioSkill">;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            rule: z.ZodOptional<z.ZodString>;
+            pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            command: z.ZodString;
+            packageName: z.ZodOptional<z.ZodString>;
+            args: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            requiredEnv: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"mcpSseSkill">;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            rule: z.ZodOptional<z.ZodString>;
+            pick: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            omit: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+            endpoint: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"interactiveSkill">;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            rule: z.ZodOptional<z.ZodString>;
+            tools: z.ZodPipe<z.ZodRecord<z.ZodString, z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                inputJsonSchema: z.ZodString;
+            }, z.core.$strip>>, z.ZodTransform<{
+                [k: string]: {
+                    name: string;
+                    inputJsonSchema: string;
+                    description?: string | undefined;
+                };
+            }, Record<string, {
+                inputJsonSchema: string;
+                description?: string | undefined;
+            }>>>;
+        }, z.core.$strip>], "type">>;
+        delegates: z.ZodArray<z.ZodString>;
+        tags: z.ZodArray<z.ZodString>;
+        toolDefinitions: z.ZodArray<z.ZodObject<{
+            skillName: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            inputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=lockfile.d.ts.map

package/dist/src/schemas/lockfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockfile.d.ts","sourceRoot":"","sources":["../../../src/schemas/lockfile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAGvC,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACrC;AAED,eAAO,MAAM,4BAA4B;;;;;iBAKvC,CAAA;AAEF,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,eAAe,EAAE,sBAAsB,EAAE,CAAA;CAC1C;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAU/B,CAAA;AAEF,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,GAAG,CAAA;IACZ,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;CACxC;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKzB,CAAA"}

package/dist/src/schemas/lockfile.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { skillSchema } from "./skill.js";
+export const lockfileToolDefinitionSchema = z.object({
+    skillName: z.string(),
+    name: z.string(),
+    description: z.string().optional(),
+    inputSchema: z.record(z.string(), z.unknown()),
+});
+export const lockfileExpertSchema = z.object({
+    key: z.string(),
+    name: z.string(),
+    version: z.string(),
+    description: z.string().optional(),
+    instruction: z.string(),
+    skills: z.record(z.string(), skillSchema),
+    delegates: z.array(z.string()),
+    tags: z.array(z.string()),
+    toolDefinitions: z.array(lockfileToolDefinitionSchema),
+});
+export const lockfileSchema = z.object({
+    version: z.literal("1"),
+    generatedAt: z.number(),
+    configPath: z.string(),
+    experts: z.record(z.string(), lockfileExpertSchema),
+});
+//# sourceMappingURL=lockfile.js.map

package/dist/src/schemas/lockfile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockfile.js","sourceRoot":"","sources":["../../../src/schemas/lockfile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AASxC,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,WAAW,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;CAC/C,CAAC,CAAA;AAcF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3C,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE;IACf,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAClC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,WAAW,CAAC;IACzC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC9B,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IACzB,eAAe,EAAE,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC;CACvD,CAAC,CAAA;AASF,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC;IACvB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,oBAAoB,CAAC;CACpD,CAAC,CAAA"}