@elie-laloum/outpost 4.2.0 → 5.0.0

package/dist/domain/hook.types.d.ts

@@ -0,0 +1,66 @@
+import type { AgentModel, ModelMessage, ModelResult, ModelToolCallBlock } from "./model.types.ts";
+import type { SandboxLease } from "./sandbox.types.ts";
+import type { ToolOutput } from "./tool.types.ts";
+export type HarnessHookPhase = "session-start" | "before-model" | "after-model" | "before-tool" | "after-tool" | "stop";
+export interface HarnessHookContext {
+    readonly sandbox: SandboxLease;
+    readonly signal: AbortSignal;
+    readonly model: AgentModel;
+    readonly step: number;
+}
+export interface HarnessToolResultView {
+    readonly content: string;
+    readonly isError: boolean;
+}
+export interface HarnessHookEvents {
+    readonly "session-start": {
+        readonly prompt: string;
+    };
+    readonly "before-model": {
+        readonly messages: readonly ModelMessage[];
+    };
+    readonly "after-model": {
+        readonly result: ModelResult;
+    };
+    readonly "before-tool": {
+        readonly call: ModelToolCallBlock;
+    };
+    readonly "after-tool": {
+        readonly call: ModelToolCallBlock;
+        readonly result: HarnessToolResultView;
+    };
+    readonly stop: {
+        readonly text: string;
+    };
+}
+export interface HarnessHookDecisions {
+    readonly "session-start": {
+        readonly instructions: string;
+    };
+    readonly "before-model": never;
+    readonly "after-model": never;
+    readonly "before-tool": {
+        readonly deny: string;
+    } | {
+        readonly input: unknown;
+    };
+    readonly "after-tool": {
+        readonly result: ToolOutput;
+    };
+    readonly stop: {
+        readonly continue: string;
+    };
+}
+export type HarnessHookInput<Phase extends HarnessHookPhase> = HarnessHookEvents[Phase] & HarnessHookContext;
+export type HarnessHookResult<Phase extends HarnessHookPhase> = HarnessHookDecisions[Phase] | undefined | void;
+export interface HarnessHookOptions<Phase extends HarnessHookPhase> {
+    readonly on: Phase;
+    readonly name?: string;
+    run(input: HarnessHookInput<Phase>): HarnessHookResult<Phase> | Promise<HarnessHookResult<Phase>>;
+}
+export interface HarnessHook<Phase extends HarnessHookPhase = HarnessHookPhase> {
+    readonly kind: "hook";
+    readonly on: Phase;
+    readonly name: string;
+    run(input: HarnessHookInput<Phase>): HarnessHookResult<Phase> | Promise<HarnessHookResult<Phase>>;
+}

package/dist/domain/hook.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hook.types.js.map

package/dist/domain/hook.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.types.js","sourceRoot":"","sources":["../../src/domain/hook.types.ts"],"names":[],"mappings":"","sourcesContent":["import type {\n  AgentModel,\n  ModelMessage,\n  ModelResult,\n  ModelToolCallBlock,\n} from \"./model.types.ts\";\nimport type { SandboxLease } from \"./sandbox.types.ts\";\nimport type { ToolOutput } from \"./tool.types.ts\";\n\nexport type HarnessHookPhase =\n  | \"session-start\"\n  | \"before-model\"\n  | \"after-model\"\n  | \"before-tool\"\n  | \"after-tool\"\n  | \"stop\";\n\nexport interface HarnessHookContext {\n  readonly sandbox: SandboxLease;\n  readonly signal: AbortSignal;\n  readonly model: AgentModel;\n  readonly step: number;\n}\n\nexport interface HarnessToolResultView {\n  readonly content: string;\n  readonly isError: boolean;\n}\n\nexport interface HarnessHookEvents {\n  readonly \"session-start\": { readonly prompt: string };\n  readonly \"before-model\": { readonly messages: readonly ModelMessage[] };\n  readonly \"after-model\": { readonly result: ModelResult };\n  readonly \"before-tool\": { readonly call: ModelToolCallBlock };\n  readonly \"after-tool\": {\n    readonly call: ModelToolCallBlock;\n    readonly result: HarnessToolResultView;\n  };\n  readonly stop: { readonly text: string };\n}\n\nexport interface HarnessHookDecisions {\n  readonly \"session-start\": { readonly instructions: string };\n  readonly \"before-model\": never;\n  readonly \"after-model\": never;\n  readonly \"before-tool\":\n    { readonly deny: string } | { readonly input: unknown };\n  readonly \"after-tool\": { readonly result: ToolOutput };\n  readonly stop: { readonly continue: string };\n}\n\nexport type HarnessHookInput<Phase extends HarnessHookPhase> =\n  HarnessHookEvents[Phase] & HarnessHookContext;\n\nexport type HarnessHookResult<Phase extends HarnessHookPhase> =\n  HarnessHookDecisions[Phase] | undefined | void;\n\nexport interface HarnessHookOptions<Phase extends HarnessHookPhase> {\n  readonly on: Phase;\n  readonly name?: string;\n  run(\n    input: HarnessHookInput<Phase>,\n  ): HarnessHookResult<Phase> | Promise<HarnessHookResult<Phase>>;\n}\n\nexport interface HarnessHook<\n  Phase extends HarnessHookPhase = HarnessHookPhase,\n> {\n  readonly kind: \"hook\";\n  readonly on: Phase;\n  readonly name: string;\n  run(\n    input: HarnessHookInput<Phase>,\n  ): HarnessHookResult<Phase> | Promise<HarnessHookResult<Phase>>;\n}\n"]}

package/dist/domain/instructions.d.ts

@@ -0,0 +1,3 @@
+import type { HarnessInstructions, HarnessInstructionSource, HarnessInstructionsOption } from "./harness.types.ts";
+export declare function defineHarnessInstructions(source: HarnessInstructionSource): HarnessInstructions;
+export declare function harnessInstructions(option: HarnessInstructionsOption | undefined): readonly HarnessInstructions[];

package/dist/domain/instructions.js

@@ -0,0 +1,25 @@
+import { invariant } from "./errors.js";
+export function defineHarnessInstructions(source) {
+    invariant(typeof source === "function" ||
+        (typeof source === "string" && source.trim()), "Instructions must be nonempty text or a function");
+    return Object.freeze({
+        kind: "instructions",
+        async resolve(context) {
+            const text = typeof source === "string" ? source : await source(context);
+            invariant(typeof text === "string", "Instructions must resolve to text");
+            return text;
+        },
+    });
+}
+export function harnessInstructions(option) {
+    if (option === undefined)
+        return [];
+    const entries = Array.isArray(option) ? option : [option];
+    return Object.freeze(entries.map((entry) => {
+        if (typeof entry === "string")
+            return defineHarnessInstructions(entry);
+        invariant(entry?.kind === "instructions", "Declare instructions as text or with defineHarnessInstructions");
+        return entry;
+    }));
+}
+//# sourceMappingURL=instructions.js.map

package/dist/domain/instructions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.js","sourceRoot":"","sources":["../../src/domain/instructions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAQxC,MAAM,UAAU,yBAAyB,CACvC,MAAgC;IAEhC,SAAS,CACP,OAAO,MAAM,KAAK,UAAU;QAC1B,CAAC,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,EAC/C,kDAAkD,CACnD,CAAC;IACF,OAAO,MAAM,CAAC,MAAM,CAAC;QACnB,IAAI,EAAE,cAAc;QACpB,KAAK,CAAC,OAAO,CAAC,OAAkC;YAC9C,MAAM,IAAI,GAAG,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,MAAM,CAAC,OAAO,CAAC,CAAC;YACzE,SAAS,CAAC,OAAO,IAAI,KAAK,QAAQ,EAAE,mCAAmC,CAAC,CAAC;YACzE,OAAO,IAAI,CAAC;QACd,CAAC;KACF,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,mBAAmB,CACjC,MAA6C;IAE7C,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,EAAE,CAAC;IACpC,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC1D,OAAO,MAAM,CAAC,MAAM,CAClB,OAAO,CAAC,GAAG,CAAC,CAAC,KAAmC,EAAE,EAAE;QAClD,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,yBAAyB,CAAC,KAAK,CAAC,CAAC;QACvE,SAAS,CACP,KAAK,EAAE,IAAI,KAAK,cAAc,EAC9B,gEAAgE,CACjE,CAAC;QACF,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CACH,CAAC;AACJ,CAAC","sourcesContent":["import { invariant } from \"./errors.ts\";\nimport type {\n  HarnessInstructionContext,\n  HarnessInstructions,\n  HarnessInstructionSource,\n  HarnessInstructionsOption,\n} from \"./harness.types.ts\";\n\nexport function defineHarnessInstructions(\n  source: HarnessInstructionSource,\n): HarnessInstructions {\n  invariant(\n    typeof source === \"function\" ||\n      (typeof source === \"string\" && source.trim()),\n    \"Instructions must be nonempty text or a function\",\n  );\n  return Object.freeze({\n    kind: \"instructions\",\n    async resolve(context: HarnessInstructionContext) {\n      const text = typeof source === \"string\" ? source : await source(context);\n      invariant(typeof text === \"string\", \"Instructions must resolve to text\");\n      return text;\n    },\n  });\n}\n\nexport function harnessInstructions(\n  option: HarnessInstructionsOption | undefined,\n): readonly HarnessInstructions[] {\n  if (option === undefined) return [];\n  const entries = Array.isArray(option) ? option : [option];\n  return Object.freeze(\n    entries.map((entry: string | HarnessInstructions) => {\n      if (typeof entry === \"string\") return defineHarnessInstructions(entry);\n      invariant(\n        entry?.kind === \"instructions\",\n        \"Declare instructions as text or with defineHarnessInstructions\",\n      );\n      return entry;\n    }),\n  );\n}\n"]}

package/dist/domain/model-messages.d.ts

@@ -0,0 +1,5 @@
+import type { ModelContentBlock, ModelMessage, ModelRequest, ModelToolSpec } from "./model.types.ts";
+export declare function requestMessages(request: ModelRequest): readonly ModelMessage[];
+export declare function validateMessages(messages: readonly ModelMessage[]): void;
+export declare function validateTools(tools: readonly ModelToolSpec[]): void;
+export declare function replayable(block: ModelContentBlock, identity: string, model: string): boolean;

package/dist/domain/model-messages.js

@@ -0,0 +1,81 @@
+import { invariant } from "./errors.js";
+import { TOOL_NAME_PATTERN } from "./model.constants.js";
+const text = (value) => typeof value === "string";
+const identifier = (value) => typeof value === "string" && value.trim() !== "";
+const blockRules = {
+    text: { role: "any", valid: (block) => text(block.text) },
+    "tool-call": {
+        role: "assistant",
+        valid: (block) => identifier(block.id) &&
+            typeof block.name === "string" &&
+            TOOL_NAME_PATTERN.test(block.name),
+    },
+    "tool-result": {
+        role: "user",
+        valid: (block) => identifier(block.callId) &&
+            text(block.content) &&
+            (block.isError === undefined || typeof block.isError === "boolean"),
+    },
+    reasoning: {
+        role: "assistant",
+        valid: (block) => identifier(block.provider) && identifier(block.model),
+    },
+};
+export function requestMessages(request) {
+    invariant((request.prompt === undefined) !== (request.messages === undefined), "Model request requires exactly one of prompt or messages");
+    if (request.messages !== undefined) {
+        validateMessages(request.messages);
+        return request.messages;
+    }
+    invariant(typeof request.prompt === "string" && request.prompt.trim(), "Model prompt must be nonempty text");
+    return [{ role: "user", content: [{ type: "text", text: request.prompt }] }];
+}
+export function validateMessages(messages) {
+    invariant(Array.isArray(messages) && messages.length > 0, "Model messages must be a nonempty array");
+    let pending = new Set();
+    for (const message of messages) {
+        invariant(message !== null &&
+            typeof message === "object" &&
+            (message.role === "user" || message.role === "assistant") &&
+            Array.isArray(message.content) &&
+            message.content.length > 0, "Model messages need a user or assistant role and content blocks");
+        const content = message.content;
+        for (const block of content)
+            validateBlock(block, message.role);
+        const results = content.flatMap((block) => block.type === "tool-result" ? [block.callId] : []);
+        invariant(results.length === pending.size &&
+            results.every((id) => pending.has(id)) &&
+            new Set(results).size === results.length, "Each tool call needs exactly one result in the next user message");
+        pending = new Set(content.flatMap((block) => block.type === "tool-call" ? [block.id] : []));
+    }
+    invariant(messages[0].role === "user" && messages.at(-1).role === "user", "Model messages must start and end with a user message");
+}
+export function validateTools(tools) {
+    invariant(Array.isArray(tools), "Model tools must be an array");
+    const names = new Set();
+    for (const tool of tools) {
+        invariant(tool !== null &&
+            typeof tool === "object" &&
+            typeof tool.name === "string" &&
+            TOOL_NAME_PATTERN.test(tool.name) &&
+            !names.has(tool.name), "Model tools need unique names of letters, digits, underscores or hyphens");
+        names.add(tool.name);
+        invariant(typeof tool.description === "string" &&
+            tool.inputSchema !== null &&
+            typeof tool.inputSchema === "object" &&
+            !Array.isArray(tool.inputSchema), "Model tools need a description and a JSON Schema object");
+    }
+}
+export function replayable(block, identity, model) {
+    return (block.type !== "reasoning" ||
+        (block.provider === identity && block.model === model));
+}
+function validateBlock(block, role) {
+    invariant(block !== null &&
+        typeof block === "object" &&
+        Object.hasOwn(blockRules, block.type), "Unsupported model content block");
+    const rule = blockRules[block.type];
+    invariant((rule.role === "any" || rule.role === role) &&
+        rule.valid(block), `Invalid ${block.type} block in a ${role} message`);
+}
+//# sourceMappingURL=model-messages.js.map

package/dist/domain/model-messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-messages.js","sourceRoot":"","sources":["../../src/domain/model-messages.ts"],"names":[],"mappings":"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","sourcesContent":["import { invariant } from \"./errors.ts\";\nimport { TOOL_NAME_PATTERN } from \"./model.constants.ts\";\nimport type { BlockRules } from \"./model-messages.types.ts\";\nimport type {\n  ModelContentBlock,\n  ModelMessage,\n  ModelRequest,\n  ModelToolSpec,\n} from \"./model.types.ts\";\n\nconst text = (value: unknown) => typeof value === \"string\";\nconst identifier = (value: unknown) =>\n  typeof value === \"string\" && value.trim() !== \"\";\n\nconst blockRules: BlockRules = {\n  text: { role: \"any\", valid: (block) => text(block.text) },\n  \"tool-call\": {\n    role: \"assistant\",\n    valid: (block) =>\n      identifier(block.id) &&\n      typeof block.name === \"string\" &&\n      TOOL_NAME_PATTERN.test(block.name),\n  },\n  \"tool-result\": {\n    role: \"user\",\n    valid: (block) =>\n      identifier(block.callId) &&\n      text(block.content) &&\n      (block.isError === undefined || typeof block.isError === \"boolean\"),\n  },\n  reasoning: {\n    role: \"assistant\",\n    valid: (block) => identifier(block.provider) && identifier(block.model),\n  },\n};\n\nexport function requestMessages(\n  request: ModelRequest,\n): readonly ModelMessage[] {\n  invariant(\n    (request.prompt === undefined) !== (request.messages === undefined),\n    \"Model request requires exactly one of prompt or messages\",\n  );\n  if (request.messages !== undefined) {\n    validateMessages(request.messages);\n    return request.messages;\n  }\n  invariant(\n    typeof request.prompt === \"string\" && request.prompt.trim(),\n    \"Model prompt must be nonempty text\",\n  );\n  return [{ role: \"user\", content: [{ type: \"text\", text: request.prompt }] }];\n}\n\nexport function validateMessages(messages: readonly ModelMessage[]): void {\n  invariant(\n    Array.isArray(messages) && messages.length > 0,\n    \"Model messages must be a nonempty array\",\n  );\n  let pending = new Set<string>();\n  for (const message of messages) {\n    invariant(\n      message !== null &&\n        typeof message === \"object\" &&\n        (message.role === \"user\" || message.role === \"assistant\") &&\n        Array.isArray(message.content) &&\n        message.content.length > 0,\n      \"Model messages need a user or assistant role and content blocks\",\n    );\n    const content: readonly ModelContentBlock[] = message.content;\n    for (const block of content) validateBlock(block, message.role);\n    const results = content.flatMap((block) =>\n      block.type === \"tool-result\" ? [block.callId] : [],\n    );\n    invariant(\n      results.length === pending.size &&\n        results.every((id) => pending.has(id)) &&\n        new Set(results).size === results.length,\n      \"Each tool call needs exactly one result in the next user message\",\n    );\n    pending = new Set(\n      content.flatMap((block) =>\n        block.type === \"tool-call\" ? [block.id] : [],\n      ),\n    );\n  }\n  invariant(\n    messages[0]!.role === \"user\" && messages.at(-1)!.role === \"user\",\n    \"Model messages must start and end with a user message\",\n  );\n}\n\nexport function validateTools(tools: readonly ModelToolSpec[]): void {\n  invariant(Array.isArray(tools), \"Model tools must be an array\");\n  const names = new Set<string>();\n  for (const tool of tools) {\n    invariant(\n      tool !== null &&\n        typeof tool === \"object\" &&\n        typeof tool.name === \"string\" &&\n        TOOL_NAME_PATTERN.test(tool.name) &&\n        !names.has(tool.name),\n      \"Model tools need unique names of letters, digits, underscores or hyphens\",\n    );\n    names.add(tool.name);\n    invariant(\n      typeof tool.description === \"string\" &&\n        tool.inputSchema !== null &&\n        typeof tool.inputSchema === \"object\" &&\n        !Array.isArray(tool.inputSchema),\n      \"Model tools need a description and a JSON Schema object\",\n    );\n  }\n}\n\nexport function replayable(\n  block: ModelContentBlock,\n  identity: string,\n  model: string,\n): boolean {\n  return (\n    block.type !== \"reasoning\" ||\n    (block.provider === identity && block.model === model)\n  );\n}\n\nfunction validateBlock(block: ModelContentBlock, role: ModelMessage[\"role\"]) {\n  invariant(\n    block !== null &&\n      typeof block === \"object\" &&\n      Object.hasOwn(blockRules, block.type),\n    \"Unsupported model content block\",\n  );\n  const rule = blockRules[block.type];\n  invariant(\n    (rule.role === \"any\" || rule.role === role) &&\n      rule.valid(block as unknown as Record<string, unknown>),\n    `Invalid ${block.type} block in a ${role} message`,\n  );\n}\n"]}

package/dist/domain/model-messages.types.d.ts

@@ -0,0 +1,6 @@
+import type { ModelContentBlock, ModelMessage } from "./model.types.ts";
+export interface BlockRule {
+    readonly role: ModelMessage["role"] | "any";
+    valid(block: Readonly<Record<string, unknown>>): boolean;
+}
+export type BlockRules = Readonly<Record<ModelContentBlock["type"], BlockRule>>;

package/dist/domain/model-messages.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model-messages.types.js.map

package/dist/domain/model-messages.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-messages.types.js","sourceRoot":"","sources":["../../src/domain/model-messages.types.ts"],"names":[],"mappings":"","sourcesContent":["import type { ModelContentBlock, ModelMessage } from \"./model.types.ts\";\n\nexport interface BlockRule {\n  readonly role: ModelMessage[\"role\"] | \"any\";\n  valid(block: Readonly<Record<string, unknown>>): boolean;\n}\n\nexport type BlockRules = Readonly<Record<ModelContentBlock[\"type\"], BlockRule>>;\n"]}

package/dist/domain/model.constants.d.ts

@@ -0,0 +1,4 @@
+import type { ModelReasoning } from "./model.types.ts";
+export declare const MODEL_REASONING: ReadonlySet<ModelReasoning>;
+export declare const AGENT_MODEL_FIELDS: ReadonlySet<string>;
+export declare const TOOL_NAME_PATTERN: RegExp;

package/dist/domain/model.constants.js

@@ -0,0 +1,16 @@
+export const MODEL_REASONING = new Set([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]);
+export const AGENT_MODEL_FIELDS = new Set([
+    "name",
+    "reasoning",
+    "maxOutputTokens",
+]);
+export const TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+//# sourceMappingURL=model.constants.js.map

package/dist/domain/model.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.constants.js","sourceRoot":"","sources":["../../src/domain/model.constants.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAgC,IAAI,GAAG,CAAC;IAClE,MAAM;IACN,SAAS;IACT,KAAK;IACL,QAAQ;IACR,MAAM;IACN,OAAO;IACP,KAAK;CACN,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAC;IAC7D,MAAM;IACN,WAAW;IACX,iBAAiB;CAClB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,uBAAuB,CAAC","sourcesContent":["import type { ModelReasoning } from \"./model.types.ts\";\n\nexport const MODEL_REASONING: ReadonlySet<ModelReasoning> = new Set([\n  \"none\",\n  \"minimal\",\n  \"low\",\n  \"medium\",\n  \"high\",\n  \"xhigh\",\n  \"max\",\n]);\n\nexport const AGENT_MODEL_FIELDS: ReadonlySet<string> = new Set([\n  \"name\",\n  \"reasoning\",\n  \"maxOutputTokens\",\n]);\n\nexport const TOOL_NAME_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;\n"]}

package/dist/domain/model.types.d.ts

@@ -1,15 +1,72 @@
 import type { Usage } from "./agent.types.ts";
+export type ModelReasoning = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export interface AgentModel {
+    readonly name: string;
+    readonly reasoning?: ModelReasoning;
+    readonly maxOutputTokens?: number;
+}
+export type ModelSpec = string | AgentModel;
+export interface ModelTextBlock {
+    readonly type: "text";
+    readonly text: string;
+}
+export interface ModelToolCallBlock {
+    readonly type: "tool-call";
+    readonly id: string;
+    readonly name: string;
+    readonly input: unknown;
+}
+export interface ModelToolResultBlock {
+    readonly type: "tool-result";
+    readonly callId: string;
+    readonly content: string;
+    readonly isError?: boolean;
+}
+export interface ModelReasoningBlock {
+    readonly type: "reasoning";
+    readonly provider: string;
+    readonly model: string;
+    readonly data: unknown;
+}
+export type ModelContentBlock = ModelTextBlock | ModelToolCallBlock | ModelToolResultBlock | ModelReasoningBlock;
+export interface ModelMessage {
+    readonly role: "user" | "assistant";
+    readonly content: readonly ModelContentBlock[];
+}
+export interface ModelToolSpec {
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+}
+export type ModelStopReason = "end" | "tool-calls" | "max-tokens" | "refusal";
 export interface ModelRequest {
-    readonly prompt: string;
+    readonly model: string;
+    readonly prompt?: string;
+    readonly messages?: readonly ModelMessage[];
     readonly system?: string;
+    readonly tools?: readonly ModelToolSpec[];
     readonly maxOutputTokens?: number;
+    readonly reasoning?: ModelReasoning;
+    readonly cache?: boolean;
     readonly signal?: AbortSignal;
 }
 export interface ModelResult {
     readonly text: string;
+    readonly content?: readonly ModelContentBlock[];
+    readonly stopReason?: ModelStopReason;
     readonly usage?: Usage;
 }
+export type ModelStreamEvent = {
+    readonly type: "text-delta";
+    readonly text: string;
+} | {
+    readonly type: "result";
+    readonly result: ModelResult;
+};
 export interface ModelProvider {
     readonly name: string;
-    generate(request: ModelRequest): Promise<ModelResult>;
+    readonly identity?: string;
+    validate?(model: AgentModel): void;
+    request(request: ModelRequest): Promise<ModelResult>;
+    stream?(request: ModelRequest): AsyncIterable<ModelStreamEvent>;
 }

package/dist/domain/model.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"model.types.js","sourceRoot":"","sources":["../../src/domain/model.types.ts"],"names":[],"mappings":"","sourcesContent":["import type { Usage } from \"./agent.types.ts\";\n\nexport interface ModelRequest {\n  readonly prompt: string;\n  readonly system?: string;\n  readonly maxOutputTokens?: number;\n  readonly signal?: AbortSignal;\n}\n\nexport interface ModelResult {\n  readonly text: string;\n  readonly usage?: Usage;\n}\n\nexport interface ModelProvider {\n  readonly name: string;\n  generate(request: ModelRequest): Promise<ModelResult>;\n}\n"]}
+{"version":3,"file":"model.types.js","sourceRoot":"","sources":["../../src/domain/model.types.ts"],"names":[],"mappings":"","sourcesContent":["import type { Usage } from \"./agent.types.ts\";\n\nexport type ModelReasoning =\n  \"none\" | \"minimal\" | \"low\" | \"medium\" | \"high\" | \"xhigh\" | \"max\";\n\nexport interface AgentModel {\n  readonly name: string;\n  readonly reasoning?: ModelReasoning;\n  readonly maxOutputTokens?: number;\n}\n\nexport type ModelSpec = string | AgentModel;\n\nexport interface ModelTextBlock {\n  readonly type: \"text\";\n  readonly text: string;\n}\n\nexport interface ModelToolCallBlock {\n  readonly type: \"tool-call\";\n  readonly id: string;\n  readonly name: string;\n  readonly input: unknown;\n}\n\nexport interface ModelToolResultBlock {\n  readonly type: \"tool-result\";\n  readonly callId: string;\n  readonly content: string;\n  readonly isError?: boolean;\n}\n\nexport interface ModelReasoningBlock {\n  readonly type: \"reasoning\";\n  readonly provider: string;\n  readonly model: string;\n  readonly data: unknown;\n}\n\nexport type ModelContentBlock =\n  | ModelTextBlock\n  | ModelToolCallBlock\n  | ModelToolResultBlock\n  | ModelReasoningBlock;\n\nexport interface ModelMessage {\n  readonly role: \"user\" | \"assistant\";\n  readonly content: readonly ModelContentBlock[];\n}\n\nexport interface ModelToolSpec {\n  readonly name: string;\n  readonly description: string;\n  readonly inputSchema: Readonly<Record<string, unknown>>;\n}\n\nexport type ModelStopReason = \"end\" | \"tool-calls\" | \"max-tokens\" | \"refusal\";\n\nexport interface ModelRequest {\n  readonly model: string;\n  readonly prompt?: string;\n  readonly messages?: readonly ModelMessage[];\n  readonly system?: string;\n  readonly tools?: readonly ModelToolSpec[];\n  readonly maxOutputTokens?: number;\n  readonly reasoning?: ModelReasoning;\n  readonly cache?: boolean;\n  readonly signal?: AbortSignal;\n}\n\nexport interface ModelResult {\n  readonly text: string;\n  readonly content?: readonly ModelContentBlock[];\n  readonly stopReason?: ModelStopReason;\n  readonly usage?: Usage;\n}\n\nexport type ModelStreamEvent =\n  | { readonly type: \"text-delta\"; readonly text: string }\n  | { readonly type: \"result\"; readonly result: ModelResult };\n\nexport interface ModelProvider {\n  readonly name: string;\n  readonly identity?: string;\n  validate?(model: AgentModel): void;\n  request(request: ModelRequest): Promise<ModelResult>;\n  stream?(request: ModelRequest): AsyncIterable<ModelStreamEvent>;\n}\n"]}

package/dist/domain/permissions.d.ts

@@ -0,0 +1,3 @@
+import type { HarnessPermissions, HarnessPermissionsOptions } from "./permissions.types.ts";
+export declare function defineHarnessPermissions(options: HarnessPermissionsOptions): HarnessPermissions;
+export declare function normalizeResourcePath(path: string): string | undefined;

package/dist/domain/permissions.js

@@ -0,0 +1,92 @@
+import { invariant } from "./errors.js";
+import { glob } from "./glob.js";
+const RULE_FIELDS = new Set(["effect", "tools", "paths", "commands", "reason"]);
+const allowed = Object.freeze({ allowed: true });
+export function defineHarnessPermissions(options) {
+    invariant(options !== null &&
+        typeof options === "object" &&
+        Array.isArray(options.rules), "Permissions require a rules array");
+    const fallback = options.default ?? "allow";
+    invariant(fallback === "allow" || fallback === "deny", 'Permission default must be "allow" or "deny"');
+    const compiled = options.rules.map(compileRule);
+    return Object.freeze({
+        kind: "permissions",
+        rules: Object.freeze(compiled.map(({ rule }) => rule)),
+        default: fallback,
+        evaluate(tool, resources) {
+            const index = compiled.findIndex((entry) => applies(entry, tool, resources));
+            const rule = compiled[index]?.rule;
+            if (rule?.effect === "allow")
+                return allowed;
+            if (rule)
+                return {
+                    allowed: false,
+                    reason: rule.reason ?? `Denied by permission rule ${index + 1}`,
+                };
+            if (fallback === "allow")
+                return allowed;
+            return { allowed: false, reason: "Denied by default permissions" };
+        },
+    });
+}
+export function normalizeResourcePath(path) {
+    const segments = [];
+    const posix = path.replaceAll("\\", "/");
+    if (posix.startsWith("/") || /^[A-Za-z]:\//.test(posix))
+        return undefined;
+    for (const segment of posix.split("/")) {
+        if (segment === "" || segment === ".")
+            continue;
+        if (segment !== "..") {
+            segments.push(segment);
+            continue;
+        }
+        if (!segments.length)
+            return undefined;
+        segments.pop();
+    }
+    return segments.join("/");
+}
+function compileRule(rule) {
+    invariant(rule !== null &&
+        typeof rule === "object" &&
+        Object.keys(rule).every((key) => RULE_FIELDS.has(key)), "Permission rules accept effect, tools, paths, commands and reason");
+    invariant(rule.effect === "allow" || rule.effect === "deny", 'Permission effect must be "allow" or "deny"');
+    invariant(rule.reason === undefined ||
+        (typeof rule.reason === "string" && rule.reason.trim()), "Permission reason must be nonempty text");
+    return Object.freeze({
+        rule: Object.freeze({ ...rule }),
+        ...patterns("tools", rule.tools, (value) => glob(value, "text")),
+        ...patterns("paths", rule.paths, (value) => glob(value, "path")),
+        ...patterns("commands", rule.commands, (value) => glob(value, "text")),
+    });
+}
+function patterns(key, values, compile) {
+    if (values === undefined)
+        return {};
+    invariant(Array.isArray(values) &&
+        values.length > 0 &&
+        values.every((value) => typeof value === "string" && value.trim()), `Permission ${key} must be a nonempty list of patterns`);
+    return { [key]: Object.freeze(values.map(compile)) };
+}
+function applies(entry, tool, resources) {
+    if (entry.tools && !entry.tools.some((pattern) => pattern.test(tool)))
+        return false;
+    if (entry.commands) {
+        const command = resources.command;
+        if (command === undefined)
+            return false;
+        if (!entry.commands.some((pattern) => pattern.test(command)))
+            return false;
+    }
+    if (!entry.paths)
+        return true;
+    const paths = (resources.paths ?? []).map(normalizeResourcePath);
+    if (!paths.length)
+        return false;
+    const matches = (path) => path !== undefined && entry.paths.some((pattern) => pattern.test(path));
+    return entry.rule.effect === "allow"
+        ? paths.every(matches)
+        : paths.some(matches);
+}
+//# sourceMappingURL=permissions.js.map

package/dist/domain/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../../src/domain/permissions.ts"],"names":[],"mappings":"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","sourcesContent":["import { invariant } from \"./errors.ts\";\nimport { glob } from \"./glob.ts\";\nimport type {\n  CompiledRule,\n  HarnessPermissionRule,\n  HarnessPermissions,\n  HarnessPermissionsOptions,\n  PermissionDecision,\n  ToolResources,\n} from \"./permissions.types.ts\";\n\nconst RULE_FIELDS = new Set([\"effect\", \"tools\", \"paths\", \"commands\", \"reason\"]);\nconst allowed: PermissionDecision = Object.freeze({ allowed: true });\n\nexport function defineHarnessPermissions(\n  options: HarnessPermissionsOptions,\n): HarnessPermissions {\n  invariant(\n    options !== null &&\n      typeof options === \"object\" &&\n      Array.isArray(options.rules),\n    \"Permissions require a rules array\",\n  );\n  const fallback = options.default ?? \"allow\";\n  invariant(\n    fallback === \"allow\" || fallback === \"deny\",\n    'Permission default must be \"allow\" or \"deny\"',\n  );\n  const compiled = options.rules.map(compileRule);\n  return Object.freeze({\n    kind: \"permissions\",\n    rules: Object.freeze(compiled.map(({ rule }) => rule)),\n    default: fallback,\n    evaluate(tool: string, resources: ToolResources): PermissionDecision {\n      const index = compiled.findIndex((entry) =>\n        applies(entry, tool, resources),\n      );\n      const rule = compiled[index]?.rule;\n      if (rule?.effect === \"allow\") return allowed;\n      if (rule)\n        return {\n          allowed: false,\n          reason: rule.reason ?? `Denied by permission rule ${index + 1}`,\n        };\n      if (fallback === \"allow\") return allowed;\n      return { allowed: false, reason: \"Denied by default permissions\" };\n    },\n  });\n}\n\nexport function normalizeResourcePath(path: string): string | undefined {\n  const segments: string[] = [];\n  const posix = path.replaceAll(\"\\\\\", \"/\");\n  if (posix.startsWith(\"/\") || /^[A-Za-z]:\\//.test(posix)) return undefined;\n  for (const segment of posix.split(\"/\")) {\n    if (segment === \"\" || segment === \".\") continue;\n    if (segment !== \"..\") {\n      segments.push(segment);\n      continue;\n    }\n    if (!segments.length) return undefined;\n    segments.pop();\n  }\n  return segments.join(\"/\");\n}\n\nfunction compileRule(rule: HarnessPermissionRule): CompiledRule {\n  invariant(\n    rule !== null &&\n      typeof rule === \"object\" &&\n      Object.keys(rule).every((key) => RULE_FIELDS.has(key)),\n    \"Permission rules accept effect, tools, paths, commands and reason\",\n  );\n  invariant(\n    rule.effect === \"allow\" || rule.effect === \"deny\",\n    'Permission effect must be \"allow\" or \"deny\"',\n  );\n  invariant(\n    rule.reason === undefined ||\n      (typeof rule.reason === \"string\" && rule.reason.trim()),\n    \"Permission reason must be nonempty text\",\n  );\n  return Object.freeze({\n    rule: Object.freeze({ ...rule }),\n    ...patterns(\"tools\", rule.tools, (value) => glob(value, \"text\")),\n    ...patterns(\"paths\", rule.paths, (value) => glob(value, \"path\")),\n    ...patterns(\"commands\", rule.commands, (value) => glob(value, \"text\")),\n  });\n}\n\nfunction patterns(\n  key: \"tools\" | \"paths\" | \"commands\",\n  values: readonly string[] | undefined,\n  compile: (value: string) => RegExp,\n) {\n  if (values === undefined) return {};\n  invariant(\n    Array.isArray(values) &&\n      values.length > 0 &&\n      values.every((value) => typeof value === \"string\" && value.trim()),\n    `Permission ${key} must be a nonempty list of patterns`,\n  );\n  return { [key]: Object.freeze(values.map(compile)) };\n}\n\nfunction applies(\n  entry: CompiledRule,\n  tool: string,\n  resources: ToolResources,\n): boolean {\n  if (entry.tools && !entry.tools.some((pattern) => pattern.test(tool)))\n    return false;\n  if (entry.commands) {\n    const command = resources.command;\n    if (command === undefined) return false;\n    if (!entry.commands.some((pattern) => pattern.test(command))) return false;\n  }\n  if (!entry.paths) return true;\n  const paths = (resources.paths ?? []).map(normalizeResourcePath);\n  if (!paths.length) return false;\n  const matches = (path: string | undefined) =>\n    path !== undefined && entry.paths!.some((pattern) => pattern.test(path));\n  return entry.rule.effect === \"allow\"\n    ? paths.every(matches)\n    : paths.some(matches);\n}\n"]}

package/dist/domain/permissions.types.d.ts

@@ -0,0 +1,34 @@
+export type PermissionEffect = "allow" | "deny";
+export interface HarnessPermissionRule {
+    readonly effect: PermissionEffect;
+    readonly tools?: readonly string[];
+    readonly paths?: readonly string[];
+    readonly commands?: readonly string[];
+    readonly reason?: string;
+}
+export interface HarnessPermissionsOptions {
+    readonly rules: readonly HarnessPermissionRule[];
+    readonly default?: PermissionEffect;
+}
+export interface ToolResources {
+    readonly paths?: readonly string[];
+    readonly command?: string;
+}
+export type PermissionDecision = {
+    readonly allowed: true;
+} | {
+    readonly allowed: false;
+    readonly reason: string;
+};
+export interface HarnessPermissions {
+    readonly kind: "permissions";
+    readonly rules: readonly HarnessPermissionRule[];
+    readonly default: PermissionEffect;
+    evaluate(tool: string, resources: ToolResources): PermissionDecision;
+}
+export interface CompiledRule {
+    readonly rule: HarnessPermissionRule;
+    readonly tools?: readonly RegExp[];
+    readonly paths?: readonly RegExp[];
+    readonly commands?: readonly RegExp[];
+}

package/dist/domain/permissions.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=permissions.types.js.map

package/dist/domain/permissions.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.types.js","sourceRoot":"","sources":["../../src/domain/permissions.types.ts"],"names":[],"mappings":"","sourcesContent":["export type PermissionEffect = \"allow\" | \"deny\";\n\nexport interface HarnessPermissionRule {\n  readonly effect: PermissionEffect;\n  readonly tools?: readonly string[];\n  readonly paths?: readonly string[];\n  readonly commands?: readonly string[];\n  readonly reason?: string;\n}\n\nexport interface HarnessPermissionsOptions {\n  readonly rules: readonly HarnessPermissionRule[];\n  readonly default?: PermissionEffect;\n}\n\nexport interface ToolResources {\n  readonly paths?: readonly string[];\n  readonly command?: string;\n}\n\nexport type PermissionDecision =\n  | { readonly allowed: true }\n  | { readonly allowed: false; readonly reason: string };\n\nexport interface HarnessPermissions {\n  readonly kind: \"permissions\";\n  readonly rules: readonly HarnessPermissionRule[];\n  readonly default: PermissionEffect;\n  evaluate(tool: string, resources: ToolResources): PermissionDecision;\n}\n\nexport interface CompiledRule {\n  readonly rule: HarnessPermissionRule;\n  readonly tools?: readonly RegExp[];\n  readonly paths?: readonly RegExp[];\n  readonly commands?: readonly RegExp[];\n}\n"]}

package/dist/domain/response.js

@@ -1,4 +1,5 @@
 import { OutpostError, invariant } from "./errors.js";
+import { validateStandard } from "./standard-schema.js";
 export class ResponseError extends OutpostError {
     tag;
     raw;
@@ -41,8 +42,8 @@ export const response = {
         const input = JSON.parse(fenced ? fenced[1] : text);
         if (typeof options.schema === "function")
             return options.schema(input);
-        const result = await options.schema["~standard"].validate(input);
-        if (result.issues)
+        const result = await validateStandard(options.schema, input);
+        if ("issues" in result)
             throw new Error(JSON.stringify(result.issues));
         return result.value;
     }),

package/dist/domain/response.js.map

@@ -1 +1 @@
-{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/domain/response.ts"],"names":[],"mappings":"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","sourcesContent":["import { OutpostError, invariant } from \"./errors.ts\";\nimport type {\n  JsonResponseOptions,\n  ResponseSpec,\n  TextResponseOptions,\n} from \"./response.types.ts\";\n\nexport type { ResponseSpec, StandardValidator } from \"./response.types.ts\";\n\nexport class ResponseError extends OutpostError {\n  readonly tag: string;\n  readonly raw: string | undefined;\n  constructor(tag: string, message: string, raw?: string, cause?: unknown) {\n    super(\"response\", message, { tag, raw }, cause);\n    this.name = \"ResponseError\";\n    this.tag = tag;\n    this.raw = raw;\n  }\n}\n\nfunction content(text: string, tag: string): string {\n  const matches = [\n    ...text.matchAll(new RegExp(`<${tag}>([\\\\s\\\\S]*?)</${tag}>`, \"g\")),\n  ];\n  if (!matches.length)\n    throw new ResponseError(tag, `No complete <${tag}> response was found`);\n  return matches.at(-1)![1]!.trim();\n}\n\nfunction spec<T>(\n  tag: string,\n  repairs: number,\n  parse: (text: string) => Promise<T>,\n): ResponseSpec<T> {\n  invariant(\n    /^[A-Za-z][A-Za-z0-9_-]*$/.test(tag),\n    \"Response tags must be XML-style identifiers\",\n  );\n  invariant(\n    Number.isSafeInteger(repairs) && repairs >= 0,\n    \"Response repairs must be a nonnegative integer\",\n  );\n  return Object.freeze({\n    tag,\n    repairs,\n    async read(text: string) {\n      const raw = content(text, tag);\n      try {\n        return await parse(raw);\n      } catch (cause) {\n        throw new ResponseError(\n          tag,\n          `Invalid <${tag}> response: ${cause instanceof Error ? cause.message : String(cause)}`,\n          raw,\n          cause,\n        );\n      }\n    },\n  });\n}\n\nexport const response = {\n  text: (options: TextResponseOptions): ResponseSpec<string> =>\n    spec(options.tag, options.repairs ?? 0, async (text) => text),\n  json: <T>(options: JsonResponseOptions<T>): ResponseSpec<T> =>\n    spec(options.tag, options.repairs ?? 0, async (text) => {\n      const fenced = text.match(/^```(?:json)?\\s*\\r?\\n([\\s\\S]*?)\\r?\\n```$/i);\n      const input: unknown = JSON.parse(fenced ? fenced[1]! : text);\n      if (typeof options.schema === \"function\") return options.schema(input);\n      const result = await options.schema[\"~standard\"].validate(input);\n      if (result.issues) throw new Error(JSON.stringify(result.issues));\n      return result.value;\n    }),\n};\n"]}
+{"version":3,"file":"response.js","sourceRoot":"","sources":["../../src/domain/response.ts"],"names":[],"mappings":"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","sourcesContent":["import { OutpostError, invariant } from \"./errors.ts\";\nimport { validateStandard } from \"./standard-schema.ts\";\nimport type {\n  JsonResponseOptions,\n  ResponseSpec,\n  TextResponseOptions,\n} from \"./response.types.ts\";\n\nexport type { ResponseSpec, StandardValidator } from \"./response.types.ts\";\n\nexport class ResponseError extends OutpostError {\n  readonly tag: string;\n  readonly raw: string | undefined;\n  constructor(tag: string, message: string, raw?: string, cause?: unknown) {\n    super(\"response\", message, { tag, raw }, cause);\n    this.name = \"ResponseError\";\n    this.tag = tag;\n    this.raw = raw;\n  }\n}\n\nfunction content(text: string, tag: string): string {\n  const matches = [\n    ...text.matchAll(new RegExp(`<${tag}>([\\\\s\\\\S]*?)</${tag}>`, \"g\")),\n  ];\n  if (!matches.length)\n    throw new ResponseError(tag, `No complete <${tag}> response was found`);\n  return matches.at(-1)![1]!.trim();\n}\n\nfunction spec<T>(\n  tag: string,\n  repairs: number,\n  parse: (text: string) => Promise<T>,\n): ResponseSpec<T> {\n  invariant(\n    /^[A-Za-z][A-Za-z0-9_-]*$/.test(tag),\n    \"Response tags must be XML-style identifiers\",\n  );\n  invariant(\n    Number.isSafeInteger(repairs) && repairs >= 0,\n    \"Response repairs must be a nonnegative integer\",\n  );\n  return Object.freeze({\n    tag,\n    repairs,\n    async read(text: string) {\n      const raw = content(text, tag);\n      try {\n        return await parse(raw);\n      } catch (cause) {\n        throw new ResponseError(\n          tag,\n          `Invalid <${tag}> response: ${cause instanceof Error ? cause.message : String(cause)}`,\n          raw,\n          cause,\n        );\n      }\n    },\n  });\n}\n\nexport const response = {\n  text: (options: TextResponseOptions): ResponseSpec<string> =>\n    spec(options.tag, options.repairs ?? 0, async (text) => text),\n  json: <T>(options: JsonResponseOptions<T>): ResponseSpec<T> =>\n    spec(options.tag, options.repairs ?? 0, async (text) => {\n      const fenced = text.match(/^```(?:json)?\\s*\\r?\\n([\\s\\S]*?)\\r?\\n```$/i);\n      const input: unknown = JSON.parse(fenced ? fenced[1]! : text);\n      if (typeof options.schema === \"function\") return options.schema(input);\n      const result = await validateStandard(options.schema, input);\n      if (\"issues\" in result) throw new Error(JSON.stringify(result.issues));\n      return result.value;\n    }),\n};\n"]}

package/dist/domain/response.types.d.ts

@@ -27,3 +27,15 @@ export type TextResponseOptions = {
     tag: string;
     repairs?: number;
 };
+export type StandardResult<T> = {
+    readonly value: T;
+} | {
+    readonly issues: readonly unknown[];
+};
+export interface StandardIssue {
+    readonly message?: unknown;
+    readonly path?: readonly unknown[];
+}
+export interface StandardPathSegment {
+    readonly key?: unknown;
+}

package/dist/domain/response.types.js.map

@@ -1 +1 @@
-{"version":3,"file":"response.types.js","sourceRoot":"","sources":["../../src/domain/response.types.ts"],"names":[],"mappings":"","sourcesContent":["export interface StandardValidator<T> {\n  readonly \"~standard\": {\n    readonly validate: (\n      input: unknown,\n    ) =>\n      | { readonly value: T; readonly issues?: undefined }\n      | { readonly issues: readonly unknown[] }\n      | Promise<\n          | { readonly value: T; readonly issues?: undefined }\n          | { readonly issues: readonly unknown[] }\n        >;\n  };\n}\n\nexport interface ResponseSpec<T> {\n  readonly tag: string;\n  readonly repairs: number;\n  read(text: string): Promise<T>;\n}\n\nexport type JsonResponseOptions<T> = {\n  tag: string;\n  schema: StandardValidator<T> | ((input: unknown) => T | Promise<T>);\n  repairs?: number;\n};\n\nexport type TextResponseOptions = { tag: string; repairs?: number };\n"]}
+{"version":3,"file":"response.types.js","sourceRoot":"","sources":["../../src/domain/response.types.ts"],"names":[],"mappings":"","sourcesContent":["export interface StandardValidator<T> {\n  readonly \"~standard\": {\n    readonly validate: (\n      input: unknown,\n    ) =>\n      | { readonly value: T; readonly issues?: undefined }\n      | { readonly issues: readonly unknown[] }\n      | Promise<\n          | { readonly value: T; readonly issues?: undefined }\n          | { readonly issues: readonly unknown[] }\n        >;\n  };\n}\n\nexport interface ResponseSpec<T> {\n  readonly tag: string;\n  readonly repairs: number;\n  read(text: string): Promise<T>;\n}\n\nexport type JsonResponseOptions<T> = {\n  tag: string;\n  schema: StandardValidator<T> | ((input: unknown) => T | Promise<T>);\n  repairs?: number;\n};\n\nexport type TextResponseOptions = { tag: string; repairs?: number };\n\nexport type StandardResult<T> =\n  { readonly value: T } | { readonly issues: readonly unknown[] };\n\nexport interface StandardIssue {\n  readonly message?: unknown;\n  readonly path?: readonly unknown[];\n}\n\nexport interface StandardPathSegment {\n  readonly key?: unknown;\n}\n"]}

package/dist/domain/skill.constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SKILL_LOADER = "load_skill";
+export declare const SKILL_FIELDS: ReadonlySet<string>;

package/dist/domain/skill.constants.js

@@ -0,0 +1,8 @@
+export const SKILL_LOADER = "load_skill";
+export const SKILL_FIELDS = new Set([
+    "name",
+    "description",
+    "instructions",
+    "tools",
+]);
+//# sourceMappingURL=skill.constants.js.map

package/dist/domain/skill.constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill.constants.js","sourceRoot":"","sources":["../../src/domain/skill.constants.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,YAAY,GAAG,YAAY,CAAC;AAEzC,MAAM,CAAC,MAAM,YAAY,GAAwB,IAAI,GAAG,CAAC;IACvD,MAAM;IACN,aAAa;IACb,cAAc;IACd,OAAO;CACR,CAAC,CAAC","sourcesContent":["export const SKILL_LOADER = \"load_skill\";\n\nexport const SKILL_FIELDS: ReadonlySet<string> = new Set([\n  \"name\",\n  \"description\",\n  \"instructions\",\n  \"tools\",\n]);\n"]}

package/dist/domain/skill.d.ts

@@ -0,0 +1,8 @@
+import type { ModelMessage } from "./model.types.ts";
+import type { HarnessSkill, HarnessSkillOptions } from "./skill.types.ts";
+import type { HarnessTool } from "./tool.types.ts";
+export declare function defineHarnessSkill(options: HarnessSkillOptions): HarnessSkill;
+export declare function harnessSkills(skills: readonly HarnessSkill[] | undefined): readonly HarnessSkill[];
+export declare function skillCatalog(skills: readonly HarnessSkill[]): string;
+export declare function skillLoader(skills: readonly HarnessSkill[]): HarnessTool;
+export declare function loadedSkills(messages: readonly ModelMessage[]): ReadonlySet<string>;