@skaile/workspaces 0.8.5

package/dist/types/src/manifests/agent.d.ts

@@ -0,0 +1,343 @@
+import * as z from "zod";
+import { type ManifestValidationResult } from "./_shared.js";
+/**
+ * Anthropic model aliases recognized by Claude Code and the Claude Agent SDK.
+ *
+ * - `inherit` — use the parent agent's model (Claude Code only).
+ * - `opus` / `sonnet` / `haiku` — auto-rolling pointer to the current top model
+ *   in that family. Resolved by Claude Code / the Claude SDK at runtime.
+ *
+ * Use these in `agent.yaml` `model.preferred` for portability across Claude
+ * Code and `claude-sdk`. Use a full ID (see {@link ANTHROPIC_FULL_ID_PATTERN})
+ * when you need to pin to a specific Anthropic release.
+ */
+export declare const ANTHROPIC_MODEL_ALIASES: readonly ["inherit", "opus", "sonnet", "haiku"];
+export type AnthropicModelAlias = (typeof ANTHROPIC_MODEL_ALIASES)[number];
+/**
+ * Regex matching a full Anthropic model identifier, optionally provider-prefixed.
+ *
+ * Accepts both the Claude 4+ "family-first" form and the legacy "version-first"
+ * form used by Claude 3.x and some OpenRouter aliases.
+ *
+ * Examples that match (family-first):
+ * - `claude-opus-4-6`
+ * - `claude-sonnet-4-5`
+ * - `claude-haiku-4-5-20251001`
+ * - `anthropic/claude-sonnet-4.6` (OpenRouter form)
+ *
+ * Examples that match (version-first / legacy):
+ * - `claude-3-5-sonnet-20241022`
+ * - `anthropic/claude-3.7-sonnet`
+ *
+ * The version segment requires at least two numeric components separated by
+ * `-` or `.`, so partial IDs like `claude-opus-4` (missing minor version) are
+ * correctly rejected.
+ */
+export declare const ANTHROPIC_FULL_ID_PATTERN: RegExp;
+/**
+ * Zod schema accepting either a Claude Code alias or a full Anthropic ID.
+ *
+ * Anything else fails validation. Use {@link normalizeAnthropicModel} to coerce
+ * unrecognized values to a safe alias instead of failing.
+ */
+export declare const ModelIdSchema: z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>;
+/**
+ * Normalize an arbitrary model string to a safe Claude Code value.
+ *
+ * - If `input` is a recognized alias or full ID, returns it unchanged.
+ * - If `input` looks like `claude-<family>-...` but doesn't match the full-ID
+ *   regex (e.g. the broken `claude-opus-4`), returns the family alias.
+ * - Otherwise returns `fallback` (default `"sonnet"` — Claude Code's default).
+ *
+ * Used by renderers that target Claude Code / the Claude SDK to coerce stale
+ * or malformed model fields into a working alias rather than propagating a
+ * silent runtime failure.
+ */
+export declare function normalizeAnthropicModel(input: string | undefined | null, fallback?: AnthropicModelAlias): string;
+export declare const BindingValues: readonly ["discoverable", "inline-live", "inline-snapshot"];
+export declare const BindingSchema: z.ZodEnum<["discoverable", "inline-live", "inline-snapshot"]>;
+export type Binding = z.infer<typeof BindingSchema>;
+/**
+ * A single composition item within an agent's `composes:` field.
+ *
+ * - `kind`: the asset kind being composed (skill, connector, ruleset, etc.)
+ * - `ref`: asset ref (e.g. '@skaile/gmail@^1')
+ * - `instance`: optional Library Instance ref to reuse (e.g. 'library://personal/instances/uuid')
+ * - `binding`: how the asset integrates into the agent runtime; defaults per-kind
+ */
+export declare const AgentComposeItemSchema: z.ZodObject<{
+    kind: z.ZodString;
+    ref: z.ZodString;
+    instance: z.ZodOptional<z.ZodString>;
+    binding: z.ZodOptional<z.ZodEnum<["discoverable", "inline-live", "inline-snapshot"]>>;
+}, "strip", z.ZodTypeAny, {
+    ref: string;
+    kind: string;
+    instance?: string | undefined;
+    binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+}, {
+    ref: string;
+    kind: string;
+    instance?: string | undefined;
+    binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+}>;
+export type AgentComposeItem = z.infer<typeof AgentComposeItemSchema>;
+export declare const AgentManifestSchema: z.ZodObject<{
+    spec_version: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    extends: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodObject<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        mode: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        mode: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    author: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    composes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        ref: z.ZodString;
+        instance: z.ZodOptional<z.ZodString>;
+        binding: z.ZodOptional<z.ZodEnum<["discoverable", "inline-live", "inline-snapshot"]>>;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+        kind: string;
+        instance?: string | undefined;
+        binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+    }, {
+        ref: string;
+        kind: string;
+        instance?: string | undefined;
+        binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+    }>, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    spec_version: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    extends: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodObject<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        mode: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        mode: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    author: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    composes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        ref: z.ZodString;
+        instance: z.ZodOptional<z.ZodString>;
+        binding: z.ZodOptional<z.ZodEnum<["discoverable", "inline-live", "inline-snapshot"]>>;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+        kind: string;
+        instance?: string | undefined;
+        binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+    }, {
+        ref: string;
+        kind: string;
+        instance?: string | undefined;
+        binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+    }>, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    spec_version: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    extends: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodObject<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        preferred: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodEnum<["inherit", "opus", "sonnet", "haiku"]>, z.ZodString]>, "many">>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            max_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    skills: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        mode: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        mode: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        max_turns: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    author: z.ZodOptional<z.ZodString>;
+    license: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    composes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        ref: z.ZodString;
+        instance: z.ZodOptional<z.ZodString>;
+        binding: z.ZodOptional<z.ZodEnum<["discoverable", "inline-live", "inline-snapshot"]>>;
+    }, "strip", z.ZodTypeAny, {
+        ref: string;
+        kind: string;
+        instance?: string | undefined;
+        binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+    }, {
+        ref: string;
+        kind: string;
+        instance?: string | undefined;
+        binding?: "discoverable" | "inline-live" | "inline-snapshot" | undefined;
+    }>, "many">>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type AgentManifest = z.infer<typeof AgentManifestSchema>;
+export declare function validateAgent(data: unknown): ManifestValidationResult<AgentManifest>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/types/src/manifests/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../../types/src/manifests/agent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAoB,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAM/E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,iDAAkD,CAAC;AACvF,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3E;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,yBAAyB,QACkF,CAAC;AAEzH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,8EAQxB,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAChC,QAAQ,GAAE,mBAA8B,GACvC,MAAM,CAOR;AAoBD,eAAO,MAAM,aAAa,6DAA8D,CAAC;AACzF,eAAO,MAAM,aAAa,+DAAwB,CAAC;AACnD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAMtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCA6BhB,CAAC;AAEjB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,wBAAwB,CAAC,aAAa,CAAC,CAEpF"}

package/dist/types/src/manifests/connector.d.ts

@@ -0,0 +1,126 @@
+import * as z from "zod";
+import { type ManifestValidationResult } from "./_shared.js";
+export declare const ConnectorManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    entry: z.ZodString;
+    npm_deps: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        optional: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        required?: string[] | undefined;
+        optional?: string[] | undefined;
+    }, {
+        required?: string[] | undefined;
+        optional?: string[] | undefined;
+    }>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        sensitive: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        type?: string | undefined;
+        default?: string | number | boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        sensitive?: boolean | undefined;
+    }, {
+        key: string;
+        type?: string | undefined;
+        default?: string | number | boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        sensitive?: boolean | undefined;
+    }>, "many">>;
+    health_check: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    license: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    entry: z.ZodString;
+    npm_deps: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        optional: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        required?: string[] | undefined;
+        optional?: string[] | undefined;
+    }, {
+        required?: string[] | undefined;
+        optional?: string[] | undefined;
+    }>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        sensitive: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        type?: string | undefined;
+        default?: string | number | boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        sensitive?: boolean | undefined;
+    }, {
+        key: string;
+        type?: string | undefined;
+        default?: string | number | boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        sensitive?: boolean | undefined;
+    }>, "many">>;
+    health_check: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    license: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    entry: z.ZodString;
+    npm_deps: z.ZodOptional<z.ZodObject<{
+        required: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        optional: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        required?: string[] | undefined;
+        optional?: string[] | undefined;
+    }, {
+        required?: string[] | undefined;
+        optional?: string[] | undefined;
+    }>>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        sensitive: z.ZodOptional<z.ZodBoolean>;
+        type: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        type?: string | undefined;
+        default?: string | number | boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        sensitive?: boolean | undefined;
+    }, {
+        key: string;
+        type?: string | undefined;
+        default?: string | number | boolean | undefined;
+        label?: string | undefined;
+        required?: boolean | undefined;
+        sensitive?: boolean | undefined;
+    }>, "many">>;
+    health_check: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    license: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export type ConnectorManifest = z.infer<typeof ConnectorManifestSchema>;
+export declare function validateConnector(data: unknown): ManifestValidationResult<ConnectorManifest>;
+//# sourceMappingURL=connector.d.ts.map

package/dist/types/src/manifests/connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector.d.ts","sourceRoot":"","sources":["../../../../types/src/manifests/connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAAiC,KAAK,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE5F,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAiBpB,CAAC;AAEjB,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,wBAAwB,CAAC,iBAAiB,CAAC,CAE5F"}

package/dist/types/src/manifests/contract.d.ts

@@ -0,0 +1,90 @@
+import * as z from "zod";
+import { type ManifestValidationResult } from "./_shared.js";
+export declare const ContractManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    license: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    license: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    license: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        version: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        stage: z.ZodOptional<z.ZodEnum<["alpha", "beta", "stable", "deprecated"]>>;
+        source: z.ZodOptional<z.ZodString>;
+        do_not_invoke: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type ContractManifest = z.infer<typeof ContractManifestSchema>;
+export declare function validateContract(data: unknown): ManifestValidationResult<ContractManifest>;
+//# sourceMappingURL=contract.d.ts.map

package/dist/types/src/manifests/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../types/src/manifests/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AACzB,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,cAAc,CAAC;AAEtB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCASnB,CAAC;AAEjB,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,wBAAwB,CAAC,gBAAgB,CAAC,CAE1F"}

package/dist/types/src/manifests/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Asset manifest schemas for all 11 kinds + Preset.
+ *
+ * Each kind exports:
+ * - <Kind>ManifestSchema (zod)
+ * - <Kind>Manifest (type)
+ * - validate<Kind>(data) -> ManifestValidationResult
+ */
+export { AssetKindSchema, AssetKindValues, BaseFrontmatterSchema, CommonMetadataSchema, FieldSchema, UserInputSchema, ArtifactRefSchema, FilePrerequisiteSchema, validateManifest, } from "./_shared.js";
+export type { AssetKind, ManifestValidationResult, ManifestValidationSuccess, ManifestValidationFailure, } from "./_shared.js";
+export { SkillManifestSchema, validateSkill } from "./skill.js";
+export type { SkillManifest } from "./skill.js";
+export { AgentManifestSchema, AgentComposeItemSchema, BindingSchema, BindingValues, validateAgent, ANTHROPIC_MODEL_ALIASES, ANTHROPIC_FULL_ID_PATTERN, ModelIdSchema, normalizeAnthropicModel, } from "./agent.js";
+export type { AgentManifest, AgentComposeItem, Binding, AnthropicModelAlias } from "./agent.js";
+export { ConnectorManifestSchema, validateConnector } from "./connector.js";
+export type { ConnectorManifest } from "./connector.js";
+export { MountManifestSchema, validateMount } from "./mount.js";
+export type { MountManifest } from "./mount.js";
+export { ContractManifestSchema, validateContract } from "./contract.js";
+export type { ContractManifest } from "./contract.js";
+export { PromptManifestSchema, validatePrompt } from "./prompt.js";
+export type { PromptManifest } from "./prompt.js";
+export { McpServerManifestSchema, validateMcpServer } from "./mcp-server.js";
+export type { McpServerManifest } from "./mcp-server.js";
+export { PersonaManifestSchema, validatePersona } from "./persona.js";
+export type { PersonaManifest } from "./persona.js";
+export { RulesetManifestSchema, validateRuleset } from "./ruleset.js";
+export type { RulesetManifest } from "./ruleset.js";
+export { PresetManifestSchema, PresetItemSchema, PlaceholderSchema, PlaceholderTypeSchema, validatePreset, } from "./preset.js";
+export type { PresetManifest, PresetItem, Placeholder } from "./preset.js";
+import type { AssetKind, ManifestValidationResult } from "./_shared.js";
+/**
+ * Validate a manifest against the schema for the given asset kind.
+ *
+ * NOTE: flow validation lives in @skaile/workspaces/base-assets/connectors/flow/engine. Use the
+ * IAssetKindRegistry for kind-agnostic validation that includes all
+ * registered providers (including extension kinds).
+ */
+export declare function validateByKind(kind: AssetKind, data: unknown): ManifestValidationResult<unknown>;
+//# sourceMappingURL=index.d.ts.map

package/dist/types/src/manifests/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../types/src/manifests/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EACL,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,oBAAoB,EACpB,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,cAAc,CAAC;AACtB,YAAY,EACV,SAAS,EACT,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,aAAa,EACb,aAAa,EACb,aAAa,EACb,uBAAuB,EACvB,yBAAyB,EACzB,aAAa,EACb,uBAAuB,GACxB,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEhG,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC5E,YAAY,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChE,YAAY,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAKhD,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACzE,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AACnE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,OAAO,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,YAAY,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAKzD,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,OAAO,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACtE,YAAY,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,cAAc,GACf,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAM3E,OAAO,KAAK,EAAE,SAAS,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AA+BxE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,GAAG,wBAAwB,CAAC,OAAO,CAAC,CAMhG"}