@full-self-browsing/lattice 1.4.0 → 1.5.0

package/dist/schema-CNfa_VEy.d.ts

@@ -0,0 +1,15 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/tools/schema.d.ts
+type JsonSchemaLike = Record<string, unknown>;
+/**
+ * Convert a Standard Schema to a JSON Schema-shaped descriptor for native
+ * provider tools and structured-output hints. Schema libraries may expose
+ * `toJSONSchema()` on the schema object; when absent we fall back to a valid
+ * object schema and keep vendor metadata inspectable.
+ */
+declare function standardSchemaToJsonSchema(schema: StandardSchemaV1): JsonSchemaLike;
+declare const toolSchemaToJsonSchema: typeof standardSchemaToJsonSchema;
+//#endregion
+export { standardSchemaToJsonSchema as n, toolSchemaToJsonSchema as r, JsonSchemaLike as t };
+//# sourceMappingURL=schema-CNfa_VEy.d.ts.map

package/dist/schema-CNfa_VEy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-CNfa_VEy.d.ts","names":[],"sources":["../src/tools/schema.ts"],"mappings":";;;KAEY,cAAA,GAAiB,MAAA;;AAA7B;;;;;iBAQgB,0BAAA,CAA2B,MAAA,EAAQ,gBAAA,GAAmB,cAAA;AAAA,cAyBzD,sBAAA,SAAsB,0BAAA"}

package/dist/storage-DJKmsaEI.d.ts

@@ -0,0 +1,26 @@
+import { r as ArtifactInput, s as ArtifactRef } from "./artifact-Bg6mJGnm.js";
+
+//#region src/storage/storage.d.ts
+interface ArtifactStore {
+  readonly kind: "artifact-store";
+  readonly id: string;
+  put(artifact: ArtifactInput): Promise<ArtifactRef>;
+  get(id: string): Promise<ArtifactRef | undefined>;
+  load(id: string): Promise<ArtifactInput | undefined>;
+  has(id: string): Promise<boolean>;
+  delete(id: string): Promise<boolean>;
+  list(): Promise<readonly ArtifactRef[]>;
+}
+type StorageLike = ArtifactStore;
+interface StoredArtifactPayloadDescriptor {
+  readonly kind: "json" | "binary";
+  readonly path: string;
+}
+interface StoredArtifactEnvelope {
+  readonly version: 1;
+  readonly ref: ArtifactRef;
+  readonly payload?: StoredArtifactPayloadDescriptor;
+}
+//#endregion
+export { StoredArtifactPayloadDescriptor as i, StorageLike as n, StoredArtifactEnvelope as r, ArtifactStore as t };
+//# sourceMappingURL=storage-DJKmsaEI.d.ts.map

package/dist/storage-DJKmsaEI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-DJKmsaEI.d.ts","names":[],"sources":["../src/storage/storage.ts"],"mappings":";;;UAEiB,aAAA;EAAA,SACN,IAAA;EAAA,SACA,EAAA;EACT,GAAA,CAAI,QAAA,EAAU,aAAA,GAAgB,OAAA,CAAQ,WAAA;EACtC,GAAA,CAAI,EAAA,WAAa,OAAA,CAAQ,WAAA;EACzB,IAAA,CAAK,EAAA,WAAa,OAAA,CAAQ,aAAA;EAC1B,GAAA,CAAI,EAAA,WAAa,OAAA;EACjB,MAAA,CAAO,EAAA,WAAa,OAAA;EACpB,IAAA,IAAQ,OAAA,UAAiB,WAAA;AAAA;AAAA,KAGf,WAAA,GAAc,aAAA;AAAA,UAET,+BAAA;EAAA,SACN,IAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,sBAAA;EAAA,SACN,OAAA;EAAA,SACA,GAAA,EAAK,WAAA;EAAA,SACL,OAAA,GAAU,+BAAA;AAAA"}

package/dist/storage.d.ts

@@ -0,0 +1,10 @@
+import { n as ArtifactFingerprint } from "./artifact-Bg6mJGnm.js";
+import { i as StoredArtifactPayloadDescriptor, n as StorageLike, r as StoredArtifactEnvelope, t as ArtifactStore } from "./storage-DJKmsaEI.js";
+import { n as createMemoryArtifactStore, t as MemoryArtifactStoreOptions } from "./memory-DRig5EHV.js";
+import { n as createLocalArtifactStore, t as LocalArtifactStoreOptions } from "./local-Dy--7peL.js";
+
+//#region src/storage/fingerprint.d.ts
+declare function fingerprintArtifactValue(value: unknown): Promise<ArtifactFingerprint | undefined>;
+//#endregion
+export { type ArtifactStore, type LocalArtifactStoreOptions, type MemoryArtifactStoreOptions, type StorageLike, type StoredArtifactEnvelope, type StoredArtifactPayloadDescriptor, createLocalArtifactStore, createMemoryArtifactStore, fingerprintArtifactValue };
+//# sourceMappingURL=storage.d.ts.map

package/dist/storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.d.ts","names":[],"sources":["../src/storage/fingerprint.ts"],"mappings":";;;;;;iBAIsB,wBAAA,CACpB,KAAA,YACC,OAAA,CAAQ,mBAAA"}

package/dist/storage.js

@@ -0,0 +1,4 @@
+import { t as fingerprintArtifactValue } from "./fingerprint-DodDbQKN.js";
+import { t as createLocalArtifactStore } from "./local-CXOGPJ1f.js";
+import { t as createMemoryArtifactStore } from "./memory-CkQEW6m5.js";
+export { createLocalArtifactStore, createMemoryArtifactStore, fingerprintArtifactValue };

package/dist/tool-call-validation-BFoXkwbf.js

@@ -0,0 +1,107 @@
+import { r as validateSchemaOutput } from "./validate-c7EL5uuH.js";
+//#region src/tools/tool-call-validation.ts
+var ToolCallValidationError = class extends Error {
+	kind = "tool-call-validation";
+	reason;
+	toolName;
+	attemptedArgs;
+	validationIssues;
+	requestId;
+	constructor(input) {
+		super(createValidationMessage(input.reason, input.toolName, input.requestId));
+		this.name = "ToolCallValidationError";
+		this.reason = input.reason;
+		this.toolName = input.toolName;
+		this.attemptedArgs = input.attemptedArgs;
+		this.validationIssues = input.validationIssues ?? [];
+		this.requestId = input.requestId;
+	}
+};
+async function validateToolCallRequests(requests, option) {
+	if (option === void 0) return;
+	const onFailure = option.onFailure ?? "throw";
+	if (onFailure === "callback" && option.onValidationFailure === void 0) throw new Error("validateToolCalls.onValidationFailure is required when onFailure is \"callback\".");
+	const toolsByName = new Map(option.tools.map((tool) => [tool.name, tool]));
+	const validCalls = [];
+	for (const request of requests) {
+		const tool = toolsByName.get(request.name);
+		if (tool === void 0) {
+			await handleValidationError(new ToolCallValidationError({
+				reason: "unknown_tool",
+				toolName: request.name,
+				attemptedArgs: request.args,
+				requestId: request.id
+			}), onFailure, option.onValidationFailure);
+			continue;
+		}
+		const validation = await validateSchemaOutput(tool.name, tool.inputSchema, request.args);
+		if (!validation.ok) {
+			await handleValidationError(new ToolCallValidationError({
+				reason: "invalid_args",
+				toolName: request.name,
+				attemptedArgs: request.args,
+				validationIssues: validation.issue.issues,
+				requestId: request.id
+			}), onFailure, option.onValidationFailure);
+			continue;
+		}
+		const extraFields = option.allowExtraFields === true ? [] : findExtraFields(tool.inputSchema, request.args);
+		if (extraFields.length > 0) {
+			await handleValidationError(new ToolCallValidationError({
+				reason: "extra_fields",
+				toolName: request.name,
+				attemptedArgs: request.args,
+				validationIssues: extraFields.map((field) => ({
+					message: `Unexpected tool argument field "${field}".`,
+					path: [field]
+				})),
+				requestId: request.id
+			}), onFailure, option.onValidationFailure);
+			continue;
+		}
+		validCalls.push({
+			id: request.id,
+			name: request.name,
+			args: validation.value
+		});
+	}
+	return validCalls;
+}
+async function handleValidationError(error, onFailure, callback) {
+	if (onFailure === "throw") throw error;
+	if (onFailure === "callback") await callback?.(error);
+}
+function findExtraFields(schema, value) {
+	if (!isRecord(value)) return [];
+	const allowedFields = getObjectSchemaKeys(schema);
+	if (allowedFields === void 0) return [];
+	const allowed = new Set(allowedFields);
+	return Object.keys(value).filter((field) => !allowed.has(field));
+}
+function getObjectSchemaKeys(schema) {
+	const candidate = schema;
+	const directShape = normalizeShape(candidate.shape);
+	if (directShape !== void 0) return directShape;
+	if (candidate.def?.type === "object") {
+		const defShape = normalizeShape(candidate.def.shape);
+		if (defShape !== void 0) return defShape;
+	}
+	if (candidate._def?.type === "object") return normalizeShape(candidate._def.shape);
+}
+function normalizeShape(shape) {
+	const resolved = typeof shape === "function" ? shape() : shape;
+	if (!isRecord(resolved)) return;
+	return Object.keys(resolved);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createValidationMessage(reason, toolName, requestId) {
+	if (reason === "unknown_tool") return `Unknown tool call "${toolName}" (${requestId}).`;
+	if (reason === "extra_fields") return `Tool call "${toolName}" contains unexpected argument fields (${requestId}).`;
+	return `Invalid arguments for tool call "${toolName}" (${requestId}).`;
+}
+//#endregion
+export { validateToolCallRequests as n, ToolCallValidationError as t };
+
+//# sourceMappingURL=tool-call-validation-BFoXkwbf.js.map

package/dist/tool-call-validation-BFoXkwbf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-call-validation-BFoXkwbf.js","names":[],"sources":["../src/tools/tool-call-validation.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nimport { validateSchemaOutput } from \"../outputs/validate.js\";\nimport type { ValidationIssue } from \"../results/errors.js\";\nimport type { ToolUseRequest } from \"./tool-use.js\";\nimport type { ToolDefinition } from \"./tools.js\";\n\nexport type ToolCallValidationFailureReason =\n  | \"unknown_tool\"\n  | \"invalid_args\"\n  | \"extra_fields\";\n\nexport interface ValidatedToolCall {\n  readonly id: string;\n  readonly name: string;\n  readonly args: unknown;\n}\n\ntype ToolCallValidationTool = Pick<ToolDefinition, \"name\" | \"inputSchema\">;\n\nexport interface ValidateToolCallsOption {\n  readonly tools: readonly ToolCallValidationTool[];\n  readonly onFailure?: \"throw\" | \"drop\" | \"callback\";\n  readonly onValidationFailure?: (error: ToolCallValidationError) => void | Promise<void>;\n  readonly allowExtraFields?: boolean;\n}\n\nexport class ToolCallValidationError extends Error {\n  readonly kind = \"tool-call-validation\" as const;\n  readonly reason: ToolCallValidationFailureReason;\n  readonly toolName: string;\n  readonly attemptedArgs: unknown;\n  readonly validationIssues: readonly ValidationIssue[];\n  readonly requestId: string;\n\n  constructor(input: {\n    readonly reason: ToolCallValidationFailureReason;\n    readonly toolName: string;\n    readonly attemptedArgs: unknown;\n    readonly validationIssues?: readonly ValidationIssue[];\n    readonly requestId: string;\n  }) {\n    super(createValidationMessage(input.reason, input.toolName, input.requestId));\n    this.name = \"ToolCallValidationError\";\n    this.reason = input.reason;\n    this.toolName = input.toolName;\n    this.attemptedArgs = input.attemptedArgs;\n    this.validationIssues = input.validationIssues ?? [];\n    this.requestId = input.requestId;\n  }\n}\n\nexport async function validateToolCallRequests(\n  requests: readonly ToolUseRequest[],\n  option: ValidateToolCallsOption | undefined,\n): Promise<readonly ValidatedToolCall[] | undefined> {\n  if (option === undefined) {\n    return undefined;\n  }\n\n  const onFailure = option.onFailure ?? \"throw\";\n  if (onFailure === \"callback\" && option.onValidationFailure === undefined) {\n    throw new Error(\n      'validateToolCalls.onValidationFailure is required when onFailure is \"callback\".',\n    );\n  }\n\n  const toolsByName = new Map(option.tools.map((tool) => [tool.name, tool]));\n  const validCalls: ValidatedToolCall[] = [];\n\n  for (const request of requests) {\n    const tool = toolsByName.get(request.name);\n    if (tool === undefined) {\n      await handleValidationError(\n        new ToolCallValidationError({\n          reason: \"unknown_tool\",\n          toolName: request.name,\n          attemptedArgs: request.args,\n          requestId: request.id,\n        }),\n        onFailure,\n        option.onValidationFailure,\n      );\n      continue;\n    }\n\n    const validation = await validateSchemaOutput(tool.name, tool.inputSchema, request.args);\n    if (!validation.ok) {\n      await handleValidationError(\n        new ToolCallValidationError({\n          reason: \"invalid_args\",\n          toolName: request.name,\n          attemptedArgs: request.args,\n          validationIssues: validation.issue.issues,\n          requestId: request.id,\n        }),\n        onFailure,\n        option.onValidationFailure,\n      );\n      continue;\n    }\n\n    const extraFields = option.allowExtraFields === true\n      ? []\n      : findExtraFields(tool.inputSchema, request.args);\n    if (extraFields.length > 0) {\n      await handleValidationError(\n        new ToolCallValidationError({\n          reason: \"extra_fields\",\n          toolName: request.name,\n          attemptedArgs: request.args,\n          validationIssues: extraFields.map((field) => ({\n            message: `Unexpected tool argument field \"${field}\".`,\n            path: [field],\n          })),\n          requestId: request.id,\n        }),\n        onFailure,\n        option.onValidationFailure,\n      );\n      continue;\n    }\n\n    validCalls.push({\n      id: request.id,\n      name: request.name,\n      args: validation.value,\n    });\n  }\n\n  return validCalls;\n}\n\nasync function handleValidationError(\n  error: ToolCallValidationError,\n  onFailure: \"throw\" | \"drop\" | \"callback\",\n  callback: ValidateToolCallsOption[\"onValidationFailure\"],\n): Promise<void> {\n  if (onFailure === \"throw\") {\n    throw error;\n  }\n  if (onFailure === \"callback\") {\n    await callback?.(error);\n  }\n}\n\nfunction findExtraFields(\n  schema: StandardSchemaV1,\n  value: unknown,\n): readonly string[] {\n  if (!isRecord(value)) {\n    return [];\n  }\n\n  const allowedFields = getObjectSchemaKeys(schema);\n  if (allowedFields === undefined) {\n    return [];\n  }\n\n  const allowed = new Set(allowedFields);\n  return Object.keys(value).filter((field) => !allowed.has(field));\n}\n\nfunction getObjectSchemaKeys(schema: StandardSchemaV1): readonly string[] | undefined {\n  const candidate = schema as {\n    readonly shape?: unknown;\n    readonly def?: { readonly type?: unknown; readonly shape?: unknown };\n    readonly _def?: { readonly type?: unknown; readonly shape?: unknown };\n  };\n\n  const directShape = normalizeShape(candidate.shape);\n  if (directShape !== undefined) {\n    return directShape;\n  }\n\n  if (candidate.def?.type === \"object\") {\n    const defShape = normalizeShape(candidate.def.shape);\n    if (defShape !== undefined) {\n      return defShape;\n    }\n  }\n\n  if (candidate._def?.type === \"object\") {\n    return normalizeShape(candidate._def.shape);\n  }\n\n  return undefined;\n}\n\nfunction normalizeShape(shape: unknown): readonly string[] | undefined {\n  const resolved = typeof shape === \"function\" ? (shape as () => unknown)() : shape;\n  if (!isRecord(resolved)) {\n    return undefined;\n  }\n\n  return Object.keys(resolved);\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction createValidationMessage(\n  reason: ToolCallValidationFailureReason,\n  toolName: string,\n  requestId: string,\n): string {\n  if (reason === \"unknown_tool\") {\n    return `Unknown tool call \"${toolName}\" (${requestId}).`;\n  }\n  if (reason === \"extra_fields\") {\n    return `Tool call \"${toolName}\" contains unexpected argument fields (${requestId}).`;\n  }\n  return `Invalid arguments for tool call \"${toolName}\" (${requestId}).`;\n}\n"],"mappings":"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"}

package/dist/tools-C4wHgGKQ.js

@@ -0,0 +1,49 @@
+import { t as artifact } from "./artifact-DOfpeXLb.js";
+import { r as validateSchemaOutput } from "./validate-c7EL5uuH.js";
+//#region src/tools/tools.ts
+function defineTool(definition) {
+	return {
+		kind: "tool",
+		...definition
+	};
+}
+async function runTool(tool, input, context = {}) {
+	const validation = await validateSchemaOutput(tool.name, tool.inputSchema, input);
+	if (!validation.ok) throw new Error(`Invalid input for tool "${tool.name}".`);
+	const callId = createToolCallId();
+	const output = await tool.execute(validation.value, context);
+	return {
+		callId,
+		toolName: tool.name,
+		artifact: artifact.toolResult(output, {
+			id: `artifact:tool-result:${tool.name}:${callId}`,
+			toolName: tool.name,
+			callId
+		})
+	};
+}
+async function importMcpTools(client, toolNames) {
+	const descriptors = await Promise.resolve(client.listTools?.() ?? []);
+	const allowed = toolNames === void 0 ? void 0 : new Set(toolNames);
+	return descriptors.filter((descriptor) => allowed === void 0 || allowed.has(descriptor.name)).map((descriptor) => defineTool({
+		name: descriptor.name,
+		...descriptor.description !== void 0 ? { description: descriptor.description } : {},
+		inputSchema: descriptor.inputSchema,
+		execute: async (input) => client.callTool({
+			name: descriptor.name,
+			arguments: input
+		})
+	}));
+}
+function toolArtifactRef(result) {
+	const { value: _value, ...ref } = result.artifact;
+	return ref;
+}
+function createToolCallId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return `${Date.now()}:${Math.random().toString(16).slice(2)}`;
+}
+//#endregion
+export { toolArtifactRef as i, importMcpTools as n, runTool as r, defineTool as t };
+
+//# sourceMappingURL=tools-C4wHgGKQ.js.map

package/dist/tools-C4wHgGKQ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools-C4wHgGKQ.js","names":[],"sources":["../src/tools/tools.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\nimport { artifact, type ArtifactInput, type ArtifactRef } from \"../artifacts/artifact.js\";\nimport { validateSchemaOutput } from \"../outputs/validate.js\";\nimport type { RunEventSink } from \"../tracing/tracing.js\";\n\nexport interface ToolExecutionContext {\n  readonly signal?: AbortSignal;\n  readonly emit?: RunEventSink;\n}\n\nexport interface ToolDefinition<TSchema extends StandardSchemaV1 = StandardSchemaV1> {\n  readonly kind: \"tool\";\n  readonly name: string;\n  readonly description?: string;\n  readonly inputSchema: TSchema;\n  readonly execute: (\n    input: StandardSchemaV1.InferOutput<TSchema>,\n    context: ToolExecutionContext,\n  ) => Promise<unknown> | unknown;\n}\n\nexport interface ToolCallResult {\n  readonly callId: string;\n  readonly toolName: string;\n  readonly artifact: ArtifactInput;\n}\n\nexport function defineTool<TSchema extends StandardSchemaV1>(\n  definition: Omit<ToolDefinition<TSchema>, \"kind\">,\n): ToolDefinition<TSchema> {\n  return {\n    kind: \"tool\",\n    ...definition,\n  };\n}\n\nexport async function runTool<TSchema extends StandardSchemaV1>(\n  tool: ToolDefinition<TSchema>,\n  input: unknown,\n  context: ToolExecutionContext = {},\n): Promise<ToolCallResult> {\n  const validation = await validateSchemaOutput(tool.name, tool.inputSchema, input);\n\n  if (!validation.ok) {\n    throw new Error(`Invalid input for tool \"${tool.name}\".`);\n  }\n\n  const callId = createToolCallId();\n  const output = await tool.execute(validation.value, context);\n\n  return {\n    callId,\n    toolName: tool.name,\n    artifact: artifact.toolResult(output, {\n      id: `artifact:tool-result:${tool.name}:${callId}`,\n      toolName: tool.name,\n      callId,\n    }),\n  };\n}\n\nexport interface McpLikeClient {\n  readonly listTools?: () => Promise<readonly McpToolDescriptor[]> | readonly McpToolDescriptor[];\n  readonly callTool: (input: {\n    readonly name: string;\n    readonly arguments: unknown;\n  }) => Promise<unknown> | unknown;\n}\n\nexport interface McpToolDescriptor {\n  readonly name: string;\n  readonly description?: string;\n  readonly inputSchema: StandardSchemaV1;\n}\n\nexport async function importMcpTools(\n  client: McpLikeClient,\n  toolNames?: readonly string[],\n): Promise<readonly ToolDefinition[]> {\n  const descriptors = await Promise.resolve(client.listTools?.() ?? []);\n  const allowed = toolNames === undefined ? undefined : new Set(toolNames);\n\n  return descriptors\n    .filter((descriptor) => allowed === undefined || allowed.has(descriptor.name))\n    .map((descriptor) =>\n      defineTool({\n        name: descriptor.name,\n        ...(descriptor.description !== undefined\n          ? { description: descriptor.description }\n          : {}),\n        inputSchema: descriptor.inputSchema,\n        execute: async (input) =>\n          client.callTool({\n            name: descriptor.name,\n            arguments: input,\n          }),\n      }),\n    );\n}\n\nexport function toolArtifactRef(result: ToolCallResult): ArtifactRef {\n  const { value: _value, ...ref } = result.artifact;\n\n  return ref;\n}\n\nfunction createToolCallId(): string {\n  if (typeof crypto !== \"undefined\" && typeof crypto.randomUUID === \"function\") {\n    return crypto.randomUUID();\n  }\n\n  return `${Date.now()}:${Math.random().toString(16).slice(2)}`;\n}\n"],"mappings":";;;AA4BA,SAAgB,WACd,YACyB;AACzB,QAAO;EACL,MAAM;EACN,GAAG;EACJ;;AAGH,eAAsB,QACpB,MACA,OACA,UAAgC,EAAE,EACT;CACzB,MAAM,aAAa,MAAM,qBAAqB,KAAK,MAAM,KAAK,aAAa,MAAM;AAEjF,KAAI,CAAC,WAAW,GACd,OAAM,IAAI,MAAM,2BAA2B,KAAK,KAAK,IAAI;CAG3D,MAAM,SAAS,kBAAkB;CACjC,MAAM,SAAS,MAAM,KAAK,QAAQ,WAAW,OAAO,QAAQ;AAE5D,QAAO;EACL;EACA,UAAU,KAAK;EACf,UAAU,SAAS,WAAW,QAAQ;GACpC,IAAI,wBAAwB,KAAK,KAAK,GAAG;GACzC,UAAU,KAAK;GACf;GACD,CAAC;EACH;;AAiBH,eAAsB,eACpB,QACA,WACoC;CACpC,MAAM,cAAc,MAAM,QAAQ,QAAQ,OAAO,aAAa,IAAI,EAAE,CAAC;CACrE,MAAM,UAAU,cAAc,KAAA,IAAY,KAAA,IAAY,IAAI,IAAI,UAAU;AAExE,QAAO,YACJ,QAAQ,eAAe,YAAY,KAAA,KAAa,QAAQ,IAAI,WAAW,KAAK,CAAC,CAC7E,KAAK,eACJ,WAAW;EACT,MAAM,WAAW;EACjB,GAAI,WAAW,gBAAgB,KAAA,IAC3B,EAAE,aAAa,WAAW,aAAa,GACvC,EAAE;EACN,aAAa,WAAW;EACxB,SAAS,OAAO,UACd,OAAO,SAAS;GACd,MAAM,WAAW;GACjB,WAAW;GACZ,CAAC;EACL,CAAC,CACH;;AAGL,SAAgB,gBAAgB,QAAqC;CACnE,MAAM,EAAE,OAAO,QAAQ,GAAG,QAAQ,OAAO;AAEzC,QAAO;;AAGT,SAAS,mBAA2B;AAClC,KAAI,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,WAChE,QAAO,OAAO,YAAY;AAG5B,QAAO,GAAG,KAAK,KAAK,CAAC,GAAG,KAAK,QAAQ,CAAC,SAAS,GAAG,CAAC,MAAM,EAAE"}

package/dist/tools.d.ts

@@ -0,0 +1,46 @@
+import { at as McpLikeClient, ct as ToolDefinition, dt as importMcpTools, et as ToolCallValidationError, ft as runTool, ht as parseToolUseEnvelope, it as validateToolCallRequests, lt as ToolExecutionContext, mt as ToolUseRequest, nt as ValidateToolCallsOption, ot as McpToolDescriptor, pt as toolArtifactRef, rt as ValidatedToolCall, st as ToolCallResult, tt as ToolCallValidationFailureReason, ut as defineTool } from "./provider-C2IfKsvz.js";
+import { o as ArtifactPrivacy, r as ArtifactInput } from "./artifact-Bg6mJGnm.js";
+import { n as standardSchemaToJsonSchema, r as toolSchemaToJsonSchema, t as JsonSchemaLike } from "./schema-CNfa_VEy.js";
+
+//#region src/tools/mcp-artifacts.d.ts
+interface McpResourceArtifactInput {
+  readonly uri: string;
+  readonly name?: string;
+  readonly title?: string;
+  readonly description?: string;
+  readonly mimeType?: string;
+  readonly text?: string;
+  readonly blob?: string;
+  readonly metadata?: Record<string, unknown>;
+}
+interface McpPromptMessage {
+  readonly role?: string;
+  readonly content: unknown;
+}
+interface McpPromptArtifactInput {
+  readonly name: string;
+  readonly description?: string;
+  readonly arguments?: Record<string, unknown>;
+  readonly messages?: readonly McpPromptMessage[];
+  readonly metadata?: Record<string, unknown>;
+}
+interface McpToolResultArtifactInput {
+  readonly toolName: string;
+  readonly callId?: string;
+  readonly content: unknown;
+  readonly isError?: boolean;
+  readonly metadata?: Record<string, unknown>;
+}
+interface McpArtifactOptions {
+  readonly id?: string;
+  readonly label?: string;
+  readonly mediaType?: string;
+  readonly metadata?: Record<string, unknown>;
+  readonly privacy?: ArtifactPrivacy;
+}
+declare function mcpResourceArtifact(input: McpResourceArtifactInput, options?: McpArtifactOptions): ArtifactInput;
+declare function mcpPromptArtifact(input: McpPromptArtifactInput, options?: McpArtifactOptions): ArtifactInput;
+declare function mcpToolResultArtifact(input: McpToolResultArtifactInput, options?: McpArtifactOptions): ArtifactInput;
+//#endregion
+export { type JsonSchemaLike, type McpArtifactOptions, type McpLikeClient, type McpPromptArtifactInput, type McpPromptMessage, type McpResourceArtifactInput, type McpToolDescriptor, type McpToolResultArtifactInput, type ToolCallResult, ToolCallValidationError, type ToolCallValidationFailureReason, type ToolDefinition, type ToolExecutionContext, type ToolUseRequest, type ValidateToolCallsOption, type ValidatedToolCall, defineTool, importMcpTools, mcpPromptArtifact, mcpResourceArtifact, mcpToolResultArtifact, parseToolUseEnvelope, runTool, standardSchemaToJsonSchema, toolArtifactRef, toolSchemaToJsonSchema, validateToolCallRequests };
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","names":[],"sources":["../src/tools/mcp-artifacts.ts"],"mappings":";;;;;UAQiB,wBAAA;EAAA,SACN,GAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;EAAA,SACA,WAAA;EAAA,SACA,QAAA;EAAA,SACA,IAAA;EAAA,SACA,IAAA;EAAA,SACA,QAAA,GAAW,MAAA;AAAA;AAAA,UAGL,gBAAA;EAAA,SACN,IAAA;EAAA,SACA,OAAA;AAAA;AAAA,UAGM,sBAAA;EAAA,SACN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA,GAAY,MAAA;EAAA,SACZ,QAAA,YAAoB,gBAAA;EAAA,SACpB,QAAA,GAAW,MAAA;AAAA;AAAA,UAGL,0BAAA;EAAA,SACN,QAAA;EAAA,SACA,MAAA;EAAA,SACA,OAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,GAAW,MAAA;AAAA;AAAA,UAGL,kBAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA;EAAA,SACA,SAAA;EAAA,SACA,QAAA,GAAW,MAAA;EAAA,SACX,OAAA,GAAU,eAAA;AAAA;AAAA,iBAGL,mBAAA,CACd,KAAA,EAAO,wBAAA,EACP,OAAA,GAAS,kBAAA,GACR,aAAA;AAAA,iBA2Ca,iBAAA,CACd,KAAA,EAAO,sBAAA,EACP,OAAA,GAAS,kBAAA,GACR,aAAA;AAAA,iBAyBa,qBAAA,CACd,KAAA,EAAO,0BAAA,EACP,OAAA,GAAS,kBAAA,GACR,aAAA"}

package/dist/tools.js

@@ -0,0 +1,106 @@
+import { t as artifact } from "./artifact-DOfpeXLb.js";
+import { a as toolSchemaToJsonSchema, i as standardSchemaToJsonSchema, o as parseToolUseEnvelope } from "./validate-c7EL5uuH.js";
+import { n as validateToolCallRequests, t as ToolCallValidationError } from "./tool-call-validation-BFoXkwbf.js";
+import { i as toolArtifactRef, n as importMcpTools, r as runTool, t as defineTool } from "./tools-C4wHgGKQ.js";
+//#region src/tools/mcp-artifacts.ts
+function mcpResourceArtifact(input, options = {}) {
+	const label = options.label ?? input.title ?? input.name ?? input.uri;
+	const metadata = createMetadata(options.metadata, {
+		kind: "resource",
+		uri: input.uri,
+		name: input.name,
+		title: input.title,
+		description: input.description,
+		mimeType: input.mimeType,
+		hasText: input.text !== void 0,
+		hasBlob: input.blob !== void 0,
+		metadata: input.metadata
+	});
+	const artifactOptions = createArtifactOptions({
+		options,
+		label,
+		metadata,
+		mediaType: options.mediaType ?? input.mimeType ?? "text/plain"
+	});
+	if (input.text !== void 0) return artifact.text(input.text, artifactOptions);
+	return artifact.json(compactObject({
+		uri: input.uri,
+		name: input.name,
+		title: input.title,
+		description: input.description,
+		mimeType: input.mimeType,
+		blob: input.blob,
+		metadata: input.metadata
+	}), createArtifactOptions({
+		options,
+		label,
+		metadata,
+		mediaType: options.mediaType ?? "application/vnd.modelcontextprotocol.resource+json"
+	}));
+}
+function mcpPromptArtifact(input, options = {}) {
+	const metadata = createMetadata(options.metadata, {
+		kind: "prompt",
+		name: input.name,
+		description: input.description,
+		metadata: input.metadata
+	});
+	return artifact.json(compactObject({
+		name: input.name,
+		description: input.description,
+		arguments: input.arguments,
+		messages: input.messages,
+		metadata: input.metadata
+	}), createArtifactOptions({
+		options,
+		label: options.label ?? input.name,
+		metadata,
+		mediaType: options.mediaType ?? "application/vnd.modelcontextprotocol.prompt+json"
+	}));
+}
+function mcpToolResultArtifact(input, options = {}) {
+	const metadata = createMetadata(options.metadata, {
+		kind: "tool-result",
+		toolName: input.toolName,
+		callId: input.callId,
+		isError: input.isError,
+		metadata: input.metadata
+	});
+	const toolOptions = {
+		toolName: input.toolName,
+		...input.callId !== void 0 ? { callId: input.callId } : {},
+		...createArtifactOptions({
+			options,
+			label: options.label ?? input.toolName,
+			metadata,
+			mediaType: options.mediaType ?? "application/json"
+		})
+	};
+	return artifact.toolResult(compactObject({
+		content: input.content,
+		isError: input.isError,
+		metadata: input.metadata
+	}), toolOptions);
+}
+function createArtifactOptions(input) {
+	return {
+		...input.options.id !== void 0 ? { id: input.options.id } : {},
+		label: input.label,
+		mediaType: input.mediaType,
+		metadata: input.metadata,
+		...input.options.privacy !== void 0 ? { privacy: input.options.privacy } : {}
+	};
+}
+function createMetadata(optionMetadata, mcp) {
+	return {
+		...optionMetadata,
+		mcp: compactObject(mcp)
+	};
+}
+function compactObject(input) {
+	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+//#endregion
+export { ToolCallValidationError, defineTool, importMcpTools, mcpPromptArtifact, mcpResourceArtifact, mcpToolResultArtifact, parseToolUseEnvelope, runTool, standardSchemaToJsonSchema, toolArtifactRef, toolSchemaToJsonSchema, validateToolCallRequests };
+
+//# sourceMappingURL=tools.js.map

package/dist/tools.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.js","names":[],"sources":["../src/tools/mcp-artifacts.ts"],"sourcesContent":["import {\n  artifact,\n  type ArtifactInput,\n  type ArtifactOptions,\n  type ArtifactPrivacy,\n  type ArtifactToolResultOptions,\n} from \"../artifacts/artifact.js\";\n\nexport interface McpResourceArtifactInput {\n  readonly uri: string;\n  readonly name?: string;\n  readonly title?: string;\n  readonly description?: string;\n  readonly mimeType?: string;\n  readonly text?: string;\n  readonly blob?: string;\n  readonly metadata?: Record<string, unknown>;\n}\n\nexport interface McpPromptMessage {\n  readonly role?: string;\n  readonly content: unknown;\n}\n\nexport interface McpPromptArtifactInput {\n  readonly name: string;\n  readonly description?: string;\n  readonly arguments?: Record<string, unknown>;\n  readonly messages?: readonly McpPromptMessage[];\n  readonly metadata?: Record<string, unknown>;\n}\n\nexport interface McpToolResultArtifactInput {\n  readonly toolName: string;\n  readonly callId?: string;\n  readonly content: unknown;\n  readonly isError?: boolean;\n  readonly metadata?: Record<string, unknown>;\n}\n\nexport interface McpArtifactOptions {\n  readonly id?: string;\n  readonly label?: string;\n  readonly mediaType?: string;\n  readonly metadata?: Record<string, unknown>;\n  readonly privacy?: ArtifactPrivacy;\n}\n\nexport function mcpResourceArtifact(\n  input: McpResourceArtifactInput,\n  options: McpArtifactOptions = {},\n): ArtifactInput {\n  const label = options.label ?? input.title ?? input.name ?? input.uri;\n  const metadata = createMetadata(options.metadata, {\n    kind: \"resource\",\n    uri: input.uri,\n    name: input.name,\n    title: input.title,\n    description: input.description,\n    mimeType: input.mimeType,\n    hasText: input.text !== undefined,\n    hasBlob: input.blob !== undefined,\n    metadata: input.metadata,\n  });\n  const artifactOptions = createArtifactOptions({\n    options,\n    label,\n    metadata,\n    mediaType: options.mediaType ?? input.mimeType ?? \"text/plain\",\n  });\n\n  if (input.text !== undefined) {\n    return artifact.text(input.text, artifactOptions);\n  }\n\n  return artifact.json(\n    compactObject({\n      uri: input.uri,\n      name: input.name,\n      title: input.title,\n      description: input.description,\n      mimeType: input.mimeType,\n      blob: input.blob,\n      metadata: input.metadata,\n    }),\n    createArtifactOptions({\n      options,\n      label,\n      metadata,\n      mediaType: options.mediaType ?? \"application/vnd.modelcontextprotocol.resource+json\",\n    }),\n  );\n}\n\nexport function mcpPromptArtifact(\n  input: McpPromptArtifactInput,\n  options: McpArtifactOptions = {},\n): ArtifactInput {\n  const metadata = createMetadata(options.metadata, {\n    kind: \"prompt\",\n    name: input.name,\n    description: input.description,\n    metadata: input.metadata,\n  });\n\n  return artifact.json(\n    compactObject({\n      name: input.name,\n      description: input.description,\n      arguments: input.arguments,\n      messages: input.messages,\n      metadata: input.metadata,\n    }),\n    createArtifactOptions({\n      options,\n      label: options.label ?? input.name,\n      metadata,\n      mediaType: options.mediaType ?? \"application/vnd.modelcontextprotocol.prompt+json\",\n    }),\n  );\n}\n\nexport function mcpToolResultArtifact(\n  input: McpToolResultArtifactInput,\n  options: McpArtifactOptions = {},\n): ArtifactInput {\n  const metadata = createMetadata(options.metadata, {\n    kind: \"tool-result\",\n    toolName: input.toolName,\n    callId: input.callId,\n    isError: input.isError,\n    metadata: input.metadata,\n  });\n  const toolOptions: ArtifactToolResultOptions = {\n    toolName: input.toolName,\n    ...(input.callId !== undefined ? { callId: input.callId } : {}),\n    ...createArtifactOptions({\n      options,\n      label: options.label ?? input.toolName,\n      metadata,\n      mediaType: options.mediaType ?? \"application/json\",\n    }),\n  };\n\n  return artifact.toolResult(\n    compactObject({\n      content: input.content,\n      isError: input.isError,\n      metadata: input.metadata,\n    }),\n    toolOptions,\n  );\n}\n\nfunction createArtifactOptions(input: {\n  readonly options: McpArtifactOptions;\n  readonly label: string;\n  readonly metadata: Record<string, unknown>;\n  readonly mediaType: string;\n}): ArtifactOptions {\n  return {\n    ...(input.options.id !== undefined ? { id: input.options.id } : {}),\n    label: input.label,\n    mediaType: input.mediaType,\n    metadata: input.metadata,\n    ...(input.options.privacy !== undefined ? { privacy: input.options.privacy } : {}),\n  };\n}\n\nfunction createMetadata(\n  optionMetadata: Record<string, unknown> | undefined,\n  mcp: Record<string, unknown>,\n): Record<string, unknown> {\n  return {\n    ...optionMetadata,\n    mcp: compactObject(mcp),\n  };\n}\n\nfunction compactObject(input: Record<string, unknown>): Record<string, unknown> {\n  return Object.fromEntries(\n    Object.entries(input).filter(([, value]) => value !== undefined),\n  );\n}\n"],"mappings":";;;;;AAgDA,SAAgB,oBACd,OACA,UAA8B,EAAE,EACjB;CACf,MAAM,QAAQ,QAAQ,SAAS,MAAM,SAAS,MAAM,QAAQ,MAAM;CAClE,MAAM,WAAW,eAAe,QAAQ,UAAU;EAChD,MAAM;EACN,KAAK,MAAM;EACX,MAAM,MAAM;EACZ,OAAO,MAAM;EACb,aAAa,MAAM;EACnB,UAAU,MAAM;EAChB,SAAS,MAAM,SAAS,KAAA;EACxB,SAAS,MAAM,SAAS,KAAA;EACxB,UAAU,MAAM;EACjB,CAAC;CACF,MAAM,kBAAkB,sBAAsB;EAC5C;EACA;EACA;EACA,WAAW,QAAQ,aAAa,MAAM,YAAY;EACnD,CAAC;AAEF,KAAI,MAAM,SAAS,KAAA,EACjB,QAAO,SAAS,KAAK,MAAM,MAAM,gBAAgB;AAGnD,QAAO,SAAS,KACd,cAAc;EACZ,KAAK,MAAM;EACX,MAAM,MAAM;EACZ,OAAO,MAAM;EACb,aAAa,MAAM;EACnB,UAAU,MAAM;EAChB,MAAM,MAAM;EACZ,UAAU,MAAM;EACjB,CAAC,EACF,sBAAsB;EACpB;EACA;EACA;EACA,WAAW,QAAQ,aAAa;EACjC,CAAC,CACH;;AAGH,SAAgB,kBACd,OACA,UAA8B,EAAE,EACjB;CACf,MAAM,WAAW,eAAe,QAAQ,UAAU;EAChD,MAAM;EACN,MAAM,MAAM;EACZ,aAAa,MAAM;EACnB,UAAU,MAAM;EACjB,CAAC;AAEF,QAAO,SAAS,KACd,cAAc;EACZ,MAAM,MAAM;EACZ,aAAa,MAAM;EACnB,WAAW,MAAM;EACjB,UAAU,MAAM;EAChB,UAAU,MAAM;EACjB,CAAC,EACF,sBAAsB;EACpB;EACA,OAAO,QAAQ,SAAS,MAAM;EAC9B;EACA,WAAW,QAAQ,aAAa;EACjC,CAAC,CACH;;AAGH,SAAgB,sBACd,OACA,UAA8B,EAAE,EACjB;CACf,MAAM,WAAW,eAAe,QAAQ,UAAU;EAChD,MAAM;EACN,UAAU,MAAM;EAChB,QAAQ,MAAM;EACd,SAAS,MAAM;EACf,UAAU,MAAM;EACjB,CAAC;CACF,MAAM,cAAyC;EAC7C,UAAU,MAAM;EAChB,GAAI,MAAM,WAAW,KAAA,IAAY,EAAE,QAAQ,MAAM,QAAQ,GAAG,EAAE;EAC9D,GAAG,sBAAsB;GACvB;GACA,OAAO,QAAQ,SAAS,MAAM;GAC9B;GACA,WAAW,QAAQ,aAAa;GACjC,CAAC;EACH;AAED,QAAO,SAAS,WACd,cAAc;EACZ,SAAS,MAAM;EACf,SAAS,MAAM;EACf,UAAU,MAAM;EACjB,CAAC,EACF,YACD;;AAGH,SAAS,sBAAsB,OAKX;AAClB,QAAO;EACL,GAAI,MAAM,QAAQ,OAAO,KAAA,IAAY,EAAE,IAAI,MAAM,QAAQ,IAAI,GAAG,EAAE;EAClE,OAAO,MAAM;EACb,WAAW,MAAM;EACjB,UAAU,MAAM;EAChB,GAAI,MAAM,QAAQ,YAAY,KAAA,IAAY,EAAE,SAAS,MAAM,QAAQ,SAAS,GAAG,EAAE;EAClF;;AAGH,SAAS,eACP,gBACA,KACyB;AACzB,QAAO;EACL,GAAG;EACH,KAAK,cAAc,IAAI;EACxB;;AAGH,SAAS,cAAc,OAAyD;AAC9E,QAAO,OAAO,YACZ,OAAO,QAAQ,MAAM,CAAC,QAAQ,GAAG,WAAW,UAAU,KAAA,EAAU,CACjE"}

package/dist/validate-c7EL5uuH.js

@@ -0,0 +1,224 @@
+import { n as isArtifactRef, r as toArtifactRef } from "./artifact-DOfpeXLb.js";
+//#region src/tools/tool-use.ts
+function parseToolUseEnvelope(responseText) {
+	if (typeof responseText !== "string" || responseText.length === 0) return null;
+	const candidates = extractJsonCandidates(responseText);
+	for (const candidate of candidates) {
+		const parsed = tryParseEnvelope(candidate);
+		if (parsed !== null) return parsed;
+	}
+	return null;
+}
+function extractJsonCandidates(text) {
+	const candidates = [];
+	const fenceRegex = /```(?:json)?\s*([\s\S]*?)```/g;
+	let fenceMatch;
+	while ((fenceMatch = fenceRegex.exec(text)) !== null) {
+		const inner = fenceMatch[1];
+		if (inner !== void 0) candidates.push(inner.trim());
+	}
+	const braceStart = text.indexOf("{");
+	const braceEnd = text.lastIndexOf("}");
+	if (braceStart !== -1 && braceEnd > braceStart) candidates.push(text.slice(braceStart, braceEnd + 1));
+	candidates.push(text.trim());
+	return candidates;
+}
+function tryParseEnvelope(jsonLike) {
+	let parsed;
+	try {
+		parsed = JSON.parse(jsonLike);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	const toolCalls = parsed["tool_calls"];
+	if (!Array.isArray(toolCalls) || toolCalls.length === 0) return null;
+	const requests = [];
+	for (const call of toolCalls) {
+		if (typeof call !== "object" || call === null) return null;
+		const callRecord = call;
+		const id = callRecord["id"];
+		const name = callRecord["name"];
+		const args = callRecord["args"];
+		if (typeof id !== "string" || typeof name !== "string") return null;
+		requests.push({
+			id,
+			name,
+			args
+		});
+	}
+	return requests;
+}
+//#endregion
+//#region src/tools/schema.ts
+/**
+* Convert a Standard Schema to a JSON Schema-shaped descriptor for native
+* provider tools and structured-output hints. Schema libraries may expose
+* `toJSONSchema()` on the schema object; when absent we fall back to a valid
+* object schema and keep vendor metadata inspectable.
+*/
+function standardSchemaToJsonSchema(schema) {
+	const maybeToJson = schema.toJSONSchema;
+	if (typeof maybeToJson === "function") try {
+		const converted = maybeToJson();
+		if (isRecord(converted)) return converted;
+	} catch {}
+	const standardSchema = schema["~standard"];
+	if (isRecord(standardSchema) && typeof standardSchema.vendor === "string") return {
+		$comment: `standard-schema vendor: ${standardSchema.vendor}; toJSONSchema not available`,
+		type: "object"
+	};
+	return {
+		$comment: "non-standard-schema input",
+		type: "object"
+	};
+}
+const toolSchemaToJsonSchema = standardSchemaToJsonSchema;
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/outputs/validate.ts
+async function validateSchemaOutput(name, schema, value) {
+	const result = schema["~standard"].validate(value);
+	const validation = result instanceof Promise ? await result : result;
+	if (validation.issues) return {
+		ok: false,
+		issue: {
+			["output"]: name,
+			issues: validation.issues.map(normalizeIssue)
+		}
+	};
+	return {
+		ok: true,
+		value: validation.value
+	};
+}
+async function validateOutputMap(contracts, rawOutputs, plan) {
+	const validation = await validateOutputMapValues(contracts, rawOutputs);
+	if (!validation.ok) return {
+		ok: false,
+		error: validation.error,
+		usage: {
+			promptTokens: 0,
+			completionTokens: 0,
+			costUsd: null
+		},
+		raw: validation.raw,
+		partialOutputs: validation.partialOutputs,
+		plan
+	};
+	return {
+		ok: true,
+		outputs: validation.outputs,
+		artifacts: [],
+		usage: {
+			promptTokens: 0,
+			completionTokens: 0,
+			costUsd: null
+		},
+		plan
+	};
+}
+async function validateOutputMapValues(contracts, rawOutputs) {
+	const outputs = {};
+	for (const [name, contract] of Object.entries(contracts)) {
+		const value = rawOutputs[name];
+		const issue = await validateOutput(name, contract, value);
+		if (!issue.ok) return {
+			ok: false,
+			error: {
+				kind: "validation",
+				message: `Invalid output "${name}".`,
+				["output"]: name,
+				issues: issue.issues
+			},
+			raw: rawOutputs,
+			partialOutputs: outputs
+		};
+		outputs[name] = issue.value;
+	}
+	return {
+		ok: true,
+		outputs
+	};
+}
+async function validateOutput(name, contract, value) {
+	if (contract === "text") {
+		if (typeof value !== "string") return {
+			ok: false,
+			issues: [{ message: "Expected text output to be a string." }]
+		};
+		return {
+			ok: true,
+			value
+		};
+	}
+	if (isStandardSchema(contract)) {
+		const result = await validateSchemaOutput(name, contract, value);
+		if (!result.ok) return {
+			ok: false,
+			issues: result.issue.issues
+		};
+		return {
+			ok: true,
+			value: result.value
+		};
+	}
+	if (contract.kind === "citations") {
+		if (!Array.isArray(value)) return {
+			ok: false,
+			issues: [{ message: "Expected citations output to be an array." }]
+		};
+		return {
+			ok: true,
+			value
+		};
+	}
+	if (contract.kind === "artifacts") {
+		if (!Array.isArray(value)) return {
+			ok: false,
+			issues: [{ message: "Expected artifacts output to be an array." }]
+		};
+		for (const item of value) {
+			if (!isArtifactRef(item)) return {
+				ok: false,
+				issues: [{ message: "Expected artifacts output item to be an artifact ref." }]
+			};
+			if (contract.artifactKind !== void 0 && item.kind !== contract.artifactKind) return {
+				ok: false,
+				issues: [{ message: `Expected artifacts output item kind to be "${contract.artifactKind}".` }]
+			};
+		}
+		return {
+			ok: true,
+			value: value.map(toArtifactRef)
+		};
+	}
+	return {
+		ok: false,
+		issues: [{ message: "Unsupported output contract." }]
+	};
+}
+function isStandardSchema(contract) {
+	if (typeof contract !== "object" || contract === null) return false;
+	return typeof contract["~standard"]?.validate === "function";
+}
+function normalizeIssue(issue) {
+	const path = issue.path?.map(normalizePathSegment).filter((segment) => segment !== void 0);
+	return {
+		message: issue.message,
+		...path !== void 0 && path.length > 0 ? { path } : {}
+	};
+}
+function normalizePathSegment(segment) {
+	if (typeof segment === "string" || typeof segment === "number" || typeof segment === "symbol") return segment;
+	return normalizePathKey(segment.key);
+}
+function normalizePathKey(key) {
+	return key;
+}
+//#endregion
+export { toolSchemaToJsonSchema as a, standardSchemaToJsonSchema as i, validateOutputMapValues as n, parseToolUseEnvelope as o, validateSchemaOutput as r, validateOutputMap as t };
+
+//# sourceMappingURL=validate-c7EL5uuH.js.map