@codeworksh/aikit 0.10.0 → 0.11.0-dev.20261012155220

package/index.mjs

@@ -1,11 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { C as NamedError, _ as optionsKey, a as KnownProviderEnumSchema, c as calculateCost, d as getModels, f as getProviders, h as modelsAreEqual, i as KnownProviderEnum, l as clampThinkingLevel, m as model_exports, n as APIMethodEnumSchema, r as ActiveThinkingLevel, s as ThinkingBudgets$1, t as APIMethodEnum, u as getModel, v as registry, y as thinkingTokenBudgetField } from "./model-Czo0SKj0.mjs";
-import { C as ToolCallSchema, D as transformMessages, E as resolveJsonSchemaConstraint, S as AssistantMessageSchema, T as message_exports, g as shortHash, n as createOpenAICodex, r as openaiCodex, v as openAICodexTools, w as createAssistantMessage$1, x as resolveOpenAICodexToolConstraint } from "./openai-codex-MpxV35tx.mjs";
-import { r as normalize, t as failure_exports } from "./failure-CN0horoO.mjs";
-import { i as packageForModel, o as resolveLanguageModel, r as loadProviderFactory } from "./registry-CZtcfRPL.mjs";
-import { i as githubCopilot, r as createGitHubCopilot } from "./github-copilot-eDhLBMfL.mjs";
+import { a as KnownProviderEnumSchema, b as thinkingTokenBudgetField, d as getModel, f as getModels, g as modelsAreEqual, h as model_exports, i as KnownProviderEnum, l as calculateCost, n as APIMethodEnumSchema, p as getProviders, r as ActiveThinkingLevel, s as ThinkingBudgets$1, t as APIMethodEnum, u as clampThinkingLevel, v as optionsKey, w as NamedError, y as registry } from "./model-D-FoGzVN.mjs";
+import { C as ToolCallSchema, E as transformMessages, S as AssistantMessageSchema, T as message_exports, g as shortHash, n as createOpenAICodex, r as openaiCodex, v as openAICodexTools, w as createAssistantMessage$1, x as resolveOpenAICodexToolConstraint } from "./openai-codex-Dj0oh0UV.mjs";
+import { r as normalize, t as failure_exports } from "./failure-DFQNKc-O.mjs";
+import { i as packageForModel, o as resolveLanguageModel, r as loadProviderFactory } from "./registry-CfGgGfSs.mjs";
+import { i as githubCopilot, r as createGitHubCopilot } from "./github-copilot-C7oJ2Tfp.mjs";
 import Type$2, { Type, Type as Type$1 } from "typebox";
-import { jsonSchema, streamText } from "ai";
+import { APICallError } from "@ai-sdk/provider";
+import { RetryError, jsonSchema, streamText } from "ai";
 import { parse } from "partial-json";
 import Schema from "typebox/schema";
 import Value from "typebox/value";
@@ -368,6 +369,8 @@ const HelperOptions = Type$1.Object({
 	sessionId: Type$1.Optional(Type$1.String()),
 	apiKey: Type$1.Optional(Type$1.String()),
 	timeoutMs: Type$1.Optional(Type$1.Number()),
+	/** Abort a stream that goes this long without a chunk, so a dead connection fails instead of waiting out `timeoutMs`. */
+	idleTimeoutMs: Type$1.Optional(Type$1.Number()),
 	maxRetries: Type$1.Optional(Type$1.Number()),
 	signal: Type$1.Optional(Type$1.Unsafe({})),
 	onPayload: Type$1.Optional(Type$1.Unsafe({})),
@@ -728,7 +731,7 @@ function disabledProviderOptions(model) {
 	if (!model.reasoning) return {};
 	const key = optionsKey(model);
 	if (key === "anthropic" || key === "google-vertex-anthropic") {
-		if (model.thinkingLevelMap?.off === null) return {};
+		if (model.thinkingLevelMap?.off === null) return { [key]: { effort: ANTHROPIC_DEFAULT_EFFORT } };
 		return { [key]: { thinking: { type: "disabled" } } };
 	}
 	if (key === "github-copilot") {
@@ -755,6 +758,8 @@ function googleDisabledThinkingConfig(model) {
 	if (model.compat?.supportsThinkingLevel) return { thinkingLevel: model.thinkingLevelMap?.off ?? "minimal" };
 	return { thinkingBudget: 0 };
 }
+/** The effort Anthropic applies when a request names none. */
+const ANTHROPIC_DEFAULT_EFFORT = "high";
 /**
 * The effort level an adaptive Claude model reasons at.
 *
@@ -827,6 +832,18 @@ function reasoningProviderOptions(model, plan) {
 	}
 	return {};
 }
+/**
+* The provider-native thinking value a request carried, read off the exact body the
+* adapter sent. Adapters drop efforts they believe a model rejects, so the options
+* aikit hands them can say more than the wire did.
+*/
+function providerThinkingLevel(body) {
+	const value = field(body, "reasoning", "effort") ?? field(body, "reasoning_effort") ?? field(body, "generationConfig", "thinkingConfig", "thinkingLevel") ?? (field(body, "thinking", "type") === "disabled" ? void 0 : field(body, "output_config", "effort"));
+	return typeof value === "string" ? value : void 0;
+}
+function field(value, ...keys) {
+	return keys.reduce((at, key) => typeof at === "object" && at !== null ? at[key] : void 0, value);
+}
 //#endregion
 //#region src/utils/jsonparse.ts
 /**
@@ -932,14 +949,170 @@ function sanitizeSurrogates(text) {
 	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
 }
 //#endregion
+//#region src/llm/strict.ts
+var UnsupportedStrictSchemaError = class extends Error {};
+const UNSUPPORTED_KEYWORDS = [
+	"$ref",
+	"$defs",
+	"definitions",
+	"allOf",
+	"oneOf",
+	"patternProperties",
+	"dependentSchemas",
+	"dependencies",
+	"unevaluatedProperties",
+	"propertyNames",
+	"contains",
+	"prefixItems",
+	"not",
+	"if",
+	"then",
+	"else"
+];
+const ANTHROPIC_UNSUPPORTED_KEYWORDS = /* @__PURE__ */ new Set([
+	"minimum",
+	"maximum",
+	"exclusiveMinimum",
+	"exclusiveMaximum",
+	"multipleOf",
+	"maxItems",
+	"uniqueItems",
+	"minContains",
+	"maxContains",
+	"minProperties",
+	"maxProperties"
+]);
+const ANTHROPIC_STRING_FORMATS = /* @__PURE__ */ new Set([
+	"date-time",
+	"time",
+	"date",
+	"duration",
+	"email",
+	"hostname",
+	"uri",
+	"ipv4",
+	"ipv6",
+	"uuid"
+]);
+const isAnthropicUnsupportedKeyword = (key, value) => {
+	if (ANTHROPIC_UNSUPPORTED_KEYWORDS.has(key)) return true;
+	if (key === "minItems") return value !== 0 && value !== 1;
+	if (key === "format") return typeof value !== "string" || !ANTHROPIC_STRING_FORMATS.has(value);
+	return false;
+};
+function isJsonSchemaObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNullSchema(schema) {
+	return isJsonSchemaObject(schema) && schema.type === "null";
+}
+/** `X` of an `anyOf: [X, null]` schema. */
+function nullableVariant(schema) {
+	if (!isJsonSchemaObject(schema) || !Array.isArray(schema.anyOf)) return;
+	const variants = schema.anyOf.filter((variant) => !isNullSchema(variant));
+	return variants.length === 1 ? variants[0] : void 0;
+}
+function isStructuredSchema(schema) {
+	if (!isJsonSchemaObject(schema)) return false;
+	const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
+	return types.includes("object") || types.includes("array") || schema.properties !== void 0 || schema.items !== void 0;
+}
+const CONSTRAINING_KEYWORDS = [
+	"type",
+	"const",
+	"enum",
+	"anyOf",
+	"allOf",
+	"oneOf",
+	"not",
+	"$ref",
+	"properties",
+	"items"
+];
+function schemaAllowsNull(schema) {
+	if (schema === true) return true;
+	if (!isJsonSchemaObject(schema)) return false;
+	if (CONSTRAINING_KEYWORDS.every((key) => schema[key] === void 0)) return true;
+	if (schema.type === "null" || Array.isArray(schema.type) && schema.type.includes("null")) return true;
+	if (schema.const === null || Array.isArray(schema.enum) && schema.enum.includes(null)) return true;
+	return Array.isArray(schema.anyOf) && schema.anyOf.some((variant) => schemaAllowsNull(variant));
+}
+function makeNodeStrict(schema, isUnsupportedKeyword) {
+	if (!isJsonSchemaObject(schema)) throw new UnsupportedStrictSchemaError("boolean schemas are unsupported");
+	for (const key of UNSUPPORTED_KEYWORDS) if (schema[key] !== void 0) throw new UnsupportedStrictSchemaError(`${key} schemas are unsupported`);
+	if (isUnsupportedKeyword) {
+		for (const [key, value] of Object.entries(schema)) if (isUnsupportedKeyword(key, value)) throw new UnsupportedStrictSchemaError(`${key}: ${JSON.stringify(value)} is unsupported`);
+	}
+	if (schema.anyOf !== void 0) {
+		if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0) throw new UnsupportedStrictSchemaError("anyOf must contain at least one schema");
+		const nullable = nullableVariant(schema) !== void 0;
+		for (const variant of schema.anyOf) {
+			if (!nullable && isStructuredSchema(variant)) throw new UnsupportedStrictSchemaError("object and array unions are unsupported");
+			makeNodeStrict(variant, isUnsupportedKeyword);
+		}
+	}
+	if (schema.items !== void 0) {
+		if (Array.isArray(schema.items)) throw new UnsupportedStrictSchemaError("tuple schemas are unsupported");
+		makeNodeStrict(schema.items, isUnsupportedKeyword);
+	}
+	const isObjectSchema = schema.type === "object";
+	if (schema.properties !== void 0 && !isObjectSchema) throw new UnsupportedStrictSchemaError("properties require type object");
+	if (!isObjectSchema) return;
+	if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties !== "boolean") throw new UnsupportedStrictSchemaError("schema-valued additionalProperties is unsupported");
+	if (schema.properties !== void 0 && !isJsonSchemaObject(schema.properties)) throw new UnsupportedStrictSchemaError("object properties must be a schema map");
+	if (schema.required !== void 0 && (!Array.isArray(schema.required) || schema.required.some((key) => typeof key !== "string"))) throw new UnsupportedStrictSchemaError("object required must be a string array");
+	const properties = schema.properties ?? {};
+	const propertyNames = Object.keys(properties);
+	const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+	if ([...required].some((key) => !propertyNames.includes(key))) throw new UnsupportedStrictSchemaError("required contains an unknown property");
+	for (const [key, property] of Object.entries(properties)) {
+		makeNodeStrict(property, isUnsupportedKeyword);
+		if (!required.has(key) && !schemaAllowsNull(property)) properties[key] = { anyOf: [property, { type: "null" }] };
+	}
+	schema.required = propertyNames;
+	schema.additionalProperties = false;
+}
+/**
+* Convert a tool's parameter schema to the subset strict constrained sampling accepts: every object closed and
+* every property required, with formerly optional properties made nullable. Callers strip those nulls again
+* before validation (see `normalizeOptionalNulls`).
+*/
+function makeStrictJsonSchema(schema, isUnsupportedKeyword) {
+	const cloned = structuredClone(schema);
+	if (!isJsonSchemaObject(cloned) || cloned.type !== "object") throw new UnsupportedStrictSchemaError("root schema must have type object");
+	makeNodeStrict(cloned, isUnsupportedKeyword);
+	return cloned;
+}
+/**
+* The strict parameter schema to send for a JSON-schema constrained tool, or `undefined` to send it non-strict.
+* A `"prefer"` tool whose schema the model's strict mode cannot express falls back to non-strict; a `"require"`
+* tool throws instead.
+*/
+function resolveStrictParameters(tool, model) {
+	const config = tool.constrainedSampling;
+	if (!config || config.type !== "json_schema") return;
+	if (model?.compat?.supportsStrictMode ?? true) {
+		const isAnthropic = model?.protocol === KnownProviderEnum.anthropic || model?.protocol === KnownProviderEnum.googleVertexAnthropic;
+		try {
+			return makeStrictJsonSchema(tool.parameters, isAnthropic ? isAnthropicUnsupportedKeyword : void 0);
+		} catch (error) {
+			if (!(error instanceof UnsupportedStrictSchemaError)) throw error;
+			if (config.strict !== "require") return;
+			throw new Error(`tool "${tool.name}" requires JSON-schema constrained sampling, but ${error.message}.`);
+		}
+	}
+	if (config.strict === "require") throw new Error(`tool "${tool.name}" requires JSON-schema constrained sampling, but strict tools are unsupported.`);
+}
+//#endregion
 //#region src/llm/transform.ts
-function createAssistantMessage(model) {
+function createAssistantMessage(model, thinkingLevel) {
 	return createAssistantMessage$1({
 		role: "assistant",
 		parts: [],
 		protocol: model.protocol,
 		provider: model.provider,
 		model: model.id,
+		thinkingLevel,
 		usage: {
 			input: 0,
 			output: 0,
@@ -1188,13 +1361,13 @@ function convertTools(tools, model) {
 	if (!tools || tools.length === 0) return;
 	const result = {};
 	for (const tool of tools) {
-		const jsonSchemaConstraint = resolveJsonSchemaConstraint(tool, model?.compat);
+		const strictParameters = resolveStrictParameters(tool, model);
 		const grammarConstraint = model?.protocol === KnownProviderEnum.openaiCodex ? resolveOpenAICodexToolConstraint(tool, model.compat) : void 0;
 		result[tool.name] = {
 			description: tool.description,
-			inputSchema: jsonSchema(tool.parameters),
-			...jsonSchemaConstraint ? { strict: true } : {},
-			...grammarConstraint?.type === "grammar" ? { providerOptions: { "openai-codex": { grammar: grammarConstraint } } } : {}
+			inputSchema: jsonSchema(strictParameters ?? tool.parameters),
+			...strictParameters ? { strict: true } : {},
+			...grammarConstraint ? { providerOptions: { "openai-codex": { grammar: grammarConstraint } } } : {}
 		};
 	}
 	return result;
@@ -1490,6 +1663,9 @@ function handlePart(part, output, model, stream, pricing) {
 		case "tool-call":
 			finalizeToolCall(output, part, stream);
 			break;
+		case "start-step":
+			stampProviderThinkingLevel(output, part.request.body);
+			break;
 		case "finish-step":
 			output.responseId ||= part.response.id;
 			if (part.response.modelId && part.response.modelId !== model.id) output.responseModel ||= part.response.modelId;
@@ -1508,6 +1684,15 @@ function handlePart(part, output, model, stream, pricing) {
 		case "error": throw part.error instanceof Error ? part.error : new Error(formatThrownError(part.error));
 	}
 }
+function stampProviderThinkingLevel(output, body) {
+	const level = providerThinkingLevel(body);
+	if (level !== void 0) output.providerThinkingLevel = level;
+}
+/** A request the provider refused never streams a `start-step`; its body travels on the error. */
+function rejectedRequestBody(error) {
+	if (RetryError.isInstance(error)) return rejectedRequestBody(error.lastError);
+	return APICallError.isInstance(error) ? error.requestBodyValues : void 0;
+}
 function resolvePricing(model, pricing) {
 	return serviceTierCostMultiplier(model, servedServiceTier(model, pricing.requestedServiceTier, pricing.providerMetadata));
 }
@@ -1531,11 +1716,21 @@ function resolveMaxOutputTokens(model, plan) {
 	if (plan.maxTokens === void 0) return void 0;
 	return isAnthropicMessagesModel(model) && !model.compat?.forceAdaptiveThinking ? plan.maxTokens - plan.budget : plan.maxTokens;
 }
+/** A bare number is a total ceiling only; the idle timeout has to be spelled per chunk. */
+function resolveTimeout(options) {
+	const { timeoutMs, idleTimeoutMs } = options;
+	if (timeoutMs === void 0 && idleTimeoutMs === void 0) return void 0;
+	return compact({
+		totalMs: timeoutMs,
+		firstChunkMs: idleTimeoutMs,
+		chunkMs: idleTimeoutMs
+	});
+}
 const stream$1 = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
 	const runtimeOptions = applyDefaultMaxTokens(model, options ?? {});
 	(async () => {
-		const output = createAssistantMessage(model);
+		const output = createAssistantMessage(model, runtimeOptions.reasoning ?? "off");
 		try {
 			const plan = resolvePlan(model, context, runtimeOptions);
 			const languageModel = await resolveAISDKLanguageModel(model, runtimeOptions, plan.budget);
@@ -1554,8 +1749,9 @@ const stream$1 = (model, context, options) => {
 				maxOutputTokens: resolveMaxOutputTokens(model, plan),
 				temperature: runtimeOptions.temperature,
 				providerOptions,
+				include: { requestBody: true },
 				abortSignal: runtimeOptions.signal,
-				timeout: runtimeOptions.timeoutMs,
+				timeout: resolveTimeout(runtimeOptions),
 				maxRetries: runtimeOptions.maxRetries,
 				headers: runtimeOptions.headers,
 				onError: () => {}
@@ -1584,6 +1780,7 @@ const stream$1 = (model, context, options) => {
 				delete block.partialJson;
 			}
 			output.time.completed = Date.now();
+			stampProviderThinkingLevel(output, rejectedRequestBody(error));
 			output.stopReason = runtimeOptions.signal?.aborted ? "aborted" : "error";
 			if (output.stopReason === "aborted") output.errorMessage = formatThrownError(error);
 			else {
@@ -1656,6 +1853,29 @@ function errorPath(error) {
 	return "root";
 }
 /**
+* Drop `null` from optional properties whose schema does not accept null, in place. Strict constrained sampling
+* makes every property required and nullable, so the model answers an omitted optional argument with `null`.
+*/
+function normalizeOptionalNulls(value, schema) {
+	const variant = nullableVariant(schema);
+	if (variant !== void 0) return normalizeOptionalNulls(value, variant);
+	const node = schema;
+	if (Array.isArray(value)) {
+		if (Array.isArray(node.items)) {
+			for (const [index, item] of value.entries()) if (node.items[index]) normalizeOptionalNulls(item, node.items[index]);
+		} else if (node.items) for (const item of value) normalizeOptionalNulls(item, node.items);
+		return;
+	}
+	if (typeof value !== "object" || value === null || !node.properties) return;
+	const object = value;
+	const required = new Set(node.required ?? []);
+	for (const [key, property] of Object.entries(node.properties)) {
+		if (!(key in object)) continue;
+		if (object[key] === null && !required.has(key) && typeof property.$ref !== "string" && !schemaAllowsNull(property)) delete object[key];
+		else normalizeOptionalNulls(object[key], property);
+	}
+}
+/**
 * Validates an arbitrary value against a TypeBox schema and returns the coerced value.
 */
 function validateSchema(schema, value, label) {
@@ -1688,9 +1908,11 @@ function validateToolCall(tools, toolExecution) {
 * Validates tool call arguments against the tool's TypeBox schema
 */
 function validateToolArguments(tool, toolExecution) {
-	return validateSchema(tool.parameters, toolExecution.rawArgs, `Tool "${toolExecution.name}"`);
+	const args = structuredClone(toolExecution.rawArgs);
+	normalizeOptionalNulls(args, tool.parameters);
+	return validateSchema(tool.parameters, args, `Tool "${toolExecution.name}"`);
 }
 //#endregion
-export { event_exports as Event, EventStream, failure_exports as Failure, message_exports as Message, model_exports as Model, protocol_exports as Protocol, ThinkingBudgets, Type, createAssistantMessageEventStream, createGitHubCopilot, createOpenAICodex, getEnvApiKey, githubCopilot, llm, openAICodexTools, openaiCodex, stream, validateSchema, validateToolArguments, validateToolCall };
+export { event_exports as Event, EventStream, failure_exports as Failure, message_exports as Message, model_exports as Model, protocol_exports as Protocol, ThinkingBudgets, Type, createAssistantMessageEventStream, createGitHubCopilot, createOpenAICodex, getEnvApiKey, githubCopilot, llm, normalizeOptionalNulls, openAICodexTools, openaiCodex, stream, validateSchema, validateToolArguments, validateToolCall };
 
 //# sourceMappingURL=index.mjs.map