@fased/fased 0.1.58 → 0.1.59

package/dist/agents/openai-responses-payload-policy.js

@@ -0,0 +1,100 @@
+import { resolveProviderRequestPolicyConfig } from "./provider-request-config.js";
+
+//#region src/agents/openai-responses-payload-policy.ts
+const OPENAI_RESPONSES_APIS = new Set(["openai-responses", "openai-codex-responses"]);
+function parsePositiveInteger(value) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+		return Math.floor(value);
+	}
+	if (typeof value === "string") {
+		const parsed = Number.parseInt(value, 10);
+		if (Number.isFinite(parsed) && parsed > 0) {
+			return parsed;
+		}
+	}
+	return undefined;
+}
+function resolveOpenAIResponsesCompactThreshold(model) {
+	const contextWindow = parsePositiveInteger(model.contextWindow);
+	if (contextWindow) {
+		return Math.max(1e3, Math.floor(contextWindow * .7));
+	}
+	return 8e4;
+}
+function shouldEnableOpenAIResponsesServerCompaction(explicitStore, provider, extraParams) {
+	const configured = extraParams?.responsesServerCompaction;
+	if (configured === false) {
+		return false;
+	}
+	if (explicitStore !== true) {
+		return false;
+	}
+	if (configured === true) {
+		return true;
+	}
+	return provider === "openai";
+}
+function stripDisabledOpenAIReasoningPayload(payloadObj) {
+	const reasoning = payloadObj.reasoning;
+	if (reasoning === "none") {
+		delete payloadObj.reasoning;
+		return;
+	}
+	if (!reasoning || typeof reasoning !== "object" || Array.isArray(reasoning)) {
+		return;
+	}
+	const reasoningObj = reasoning;
+	if (reasoningObj.effort === "none") {
+		delete payloadObj.reasoning;
+	}
+}
+function resolveOpenAIResponsesPayloadPolicy(model, options = {}) {
+	const capabilities = resolveProviderRequestPolicyConfig({
+		provider: typeof model.provider === "string" ? model.provider : undefined,
+		api: typeof model.api === "string" ? model.api : undefined,
+		baseUrl: typeof model.baseUrl === "string" ? model.baseUrl : undefined,
+		compat: model.compat,
+		capability: "llm",
+		transport: "stream"
+	}).capabilities;
+	const storeMode = options.storeMode ?? "provider-policy";
+	const explicitStore = storeMode === "preserve" ? undefined : storeMode === "disable" ? capabilities.supportsResponsesStoreField ? false : undefined : capabilities.allowsResponsesStore ? true : undefined;
+	const isResponsesApi = typeof model.api === "string" && OPENAI_RESPONSES_APIS.has(model.api);
+	return {
+		allowsServiceTier: capabilities.allowsOpenAIServiceTier,
+		compactThreshold: parsePositiveInteger(options.extraParams?.responsesCompactThreshold) ?? resolveOpenAIResponsesCompactThreshold(model),
+		explicitStore,
+		shouldStripDisabledReasoningPayload: isResponsesApi && !capabilities.usesKnownNativeOpenAIRoute,
+		shouldStripReasoningPayload: false,
+		shouldStripPromptCache: options.enablePromptCacheStripping === true && capabilities.shouldStripResponsesPromptCache,
+		shouldStripStore: explicitStore !== true && model.compat?.supportsStore === false && isResponsesApi,
+		useServerCompaction: options.enableServerCompaction === true && shouldEnableOpenAIResponsesServerCompaction(explicitStore, model.provider, options.extraParams)
+	};
+}
+function applyOpenAIResponsesPayloadPolicy(payloadObj, policy) {
+	if (policy.explicitStore !== undefined) {
+		payloadObj.store = policy.explicitStore;
+	}
+	if (policy.shouldStripStore) {
+		delete payloadObj.store;
+	}
+	if (policy.shouldStripPromptCache) {
+		delete payloadObj.prompt_cache_key;
+		delete payloadObj.prompt_cache_retention;
+	}
+	if (policy.shouldStripReasoningPayload) {
+		delete payloadObj.reasoning;
+	}
+	if (policy.useServerCompaction && payloadObj.context_management === undefined) {
+		payloadObj.context_management = [{
+			type: "compaction",
+			compact_threshold: policy.compactThreshold
+		}];
+	}
+	if (policy.shouldStripDisabledReasoningPayload) {
+		stripDisabledOpenAIReasoningPayload(payloadObj);
+	}
+}
+
+//#endregion
+export { applyOpenAIResponsesPayloadPolicy, resolveOpenAIResponsesPayloadPolicy };

package/dist/agents/openai-tool-schema.js

@@ -0,0 +1,130 @@
+import { resolveProviderRequestCapabilities } from "./provider-attribution.js";
+import { normalizeToolParameters } from "./pi-tools.schema.js";
+
+//#region src/agents/openai-tool-schema.ts
+function normalizeToolParameterSchema(schema) {
+	const normalized = normalizeToolParameters({
+		name: "schema",
+		label: "Schema",
+		description: "Schema normalization placeholder.",
+		parameters: schema,
+		execute: async () => ({
+			content: [],
+			details: {}
+		})
+	});
+	return normalized.parameters;
+}
+function optionalString(value) {
+	return typeof value === "string" ? value : undefined;
+}
+function normalizeStrictOpenAIJsonSchema(schema) {
+	return normalizeStrictOpenAIJsonSchemaRecursive(normalizeToolParameterSchema(schema ?? {}));
+}
+function normalizeStrictOpenAIJsonSchemaRecursive(schema) {
+	if (Array.isArray(schema)) {
+		let changed = false;
+		const normalized = schema.map((entry) => {
+			const next = normalizeStrictOpenAIJsonSchemaRecursive(entry);
+			changed ||= next !== entry;
+			return next;
+		});
+		return changed ? normalized : schema;
+	}
+	if (!schema || typeof schema !== "object") {
+		return schema;
+	}
+	const record = schema;
+	let changed = false;
+	const normalized = {};
+	for (const [key, value] of Object.entries(record)) {
+		const next = normalizeStrictOpenAIJsonSchemaRecursive(value);
+		normalized[key] = next;
+		changed ||= next !== value;
+	}
+	if (normalized.type === "object") {
+		const properties = normalized.properties && typeof normalized.properties === "object" && !Array.isArray(normalized.properties) ? normalized.properties : undefined;
+		if (properties && Object.keys(properties).length === 0 && !Array.isArray(normalized.required)) {
+			normalized.required = [];
+			changed = true;
+		}
+	}
+	return changed ? normalized : schema;
+}
+function normalizeOpenAIStrictToolParameters(schema, strict) {
+	if (!strict) {
+		return normalizeToolParameterSchema(schema ?? {});
+	}
+	return normalizeStrictOpenAIJsonSchema(schema);
+}
+function isStrictOpenAIJsonSchemaCompatible(schema) {
+	return isStrictOpenAIJsonSchemaCompatibleRecursive(normalizeStrictOpenAIJsonSchema(schema));
+}
+function isStrictOpenAIJsonSchemaCompatibleRecursive(schema) {
+	if (Array.isArray(schema)) {
+		return schema.every((entry) => isStrictOpenAIJsonSchemaCompatibleRecursive(entry));
+	}
+	if (!schema || typeof schema !== "object") {
+		return true;
+	}
+	const record = schema;
+	if ("anyOf" in record || "oneOf" in record || "allOf" in record) {
+		return false;
+	}
+	if (Array.isArray(record.type)) {
+		return false;
+	}
+	if (record.type === "object" && record.additionalProperties !== false) {
+		return false;
+	}
+	if (record.type === "object") {
+		const properties = record.properties && typeof record.properties === "object" && !Array.isArray(record.properties) ? record.properties : {};
+		const required = Array.isArray(record.required) ? record.required.filter((entry) => typeof entry === "string") : undefined;
+		if (!required) {
+			return false;
+		}
+		const requiredSet = new Set(required);
+		if (Object.keys(properties).some((key) => !requiredSet.has(key))) {
+			return false;
+		}
+	}
+	return Object.entries(record).every(([key, entry]) => {
+		if (key === "properties" && entry && typeof entry === "object" && !Array.isArray(entry)) {
+			return Object.values(entry).every((value) => isStrictOpenAIJsonSchemaCompatibleRecursive(value));
+		}
+		return isStrictOpenAIJsonSchemaCompatibleRecursive(entry);
+	});
+}
+function resolveOpenAIStrictToolFlagForInventory(tools, strict) {
+	if (strict !== true) {
+		return strict === false ? false : undefined;
+	}
+	return tools.every((tool) => isStrictOpenAIJsonSchemaCompatible(tool.parameters));
+}
+function resolvesToNativeOpenAIStrictTools(model, transport) {
+	const capabilities = resolveProviderRequestCapabilities({
+		provider: optionalString(model.provider),
+		api: optionalString(model.api),
+		baseUrl: optionalString(model.baseUrl),
+		capability: "llm",
+		transport,
+		modelId: optionalString(model.id),
+		compat: model.compat && typeof model.compat === "object" ? model.compat : undefined
+	});
+	if (!capabilities.usesKnownNativeOpenAIRoute) {
+		return false;
+	}
+	return capabilities.provider === "openai" || capabilities.provider === "openai-codex";
+}
+function resolveOpenAIStrictToolSetting(model, options) {
+	if (resolvesToNativeOpenAIStrictTools(model, options?.transport ?? "stream")) {
+		return true;
+	}
+	if (options?.supportsStrictMode) {
+		return false;
+	}
+	return undefined;
+}
+
+//#endregion
+export { normalizeOpenAIStrictToolParameters, resolveOpenAIStrictToolFlagForInventory, resolveOpenAIStrictToolSetting };