@keystrokehq/keystroke 1.0.13 → 1.0.14

package/dist/agent.cjs

@@ -5325,10 +5325,29 @@ function validateToolArguments(tool, toolCall) {
 	throw new Error(errorMessage);
 }
 //#endregion
-//#region ../agent/dist/schemas-DCBOj0XY.mjs
+//#region ../agent/dist/schemas-T2usEGaN.mjs
 const getModelLoose = require_event_stream.getModel;
+const DEFAULT_GATEWAY_ORIGIN = "https://ai-gateway.vercel.sh";
 const AGENT_MODEL_ID_PATTERN = /^[a-z0-9-]+\/.+/;
 const AgentModelIdSchema = zod.z.custom((value) => typeof value === "string" && AGENT_MODEL_ID_PATTERN.test(value), "model must be vendor/model-id");
+const GatewayModelPricingSchema = zod.z.object({
+	input: zod.z.string().optional(),
+	output: zod.z.string().optional(),
+	input_cache_read: zod.z.string().optional()
+});
+const GatewayModelResponseSchema = zod.z.object({
+	id: zod.z.string().min(1),
+	name: zod.z.string().optional(),
+	type: zod.z.string().optional(),
+	context_window: zod.z.number().int().positive().optional(),
+	max_tokens: zod.z.number().int().positive().optional(),
+	tags: zod.z.array(zod.z.string()).optional(),
+	pricing: GatewayModelPricingSchema.optional()
+});
+function parseGatewayModelResponse(body) {
+	const parsed = GatewayModelResponseSchema.safeParse(body);
+	return parsed.success ? parsed.data : void 0;
+}
 function splitAgentModelId(modelId) {
 	const slash = modelId.indexOf("/");
 	return {
@@ -5359,11 +5378,95 @@ function resolveGatewayBaseUrl() {
 	const projectId = require_dist$2.getProjectScopeId();
 	return `${platformUrl.replace(/\/$/, "")}/internal/projects/${encodeURIComponent(projectId)}/llm`;
 }
-function resolveGatewayModel(modelId) {
+function resolveGatewayOrigin(baseUrl) {
+	return baseUrl ?? DEFAULT_GATEWAY_ORIGIN;
+}
+function pricePerMillion(value) {
+	if (!value) return 0;
+	const perToken = Number(value);
+	if (!Number.isFinite(perToken) || perToken <= 0) return 0;
+	return perToken * 1e6;
+}
+function buildGatewayModel(raw, baseUrl) {
+	if (raw.type && raw.type !== "language") return;
+	const tags = raw.tags ?? [];
+	return {
+		id: raw.id,
+		name: raw.name ?? raw.id,
+		api: "anthropic-messages",
+		provider: "vercel-ai-gateway",
+		baseUrl: resolveGatewayOrigin(baseUrl),
+		reasoning: tags.includes("reasoning"),
+		input: tags.includes("vision") ? ["text", "image"] : ["text"],
+		cost: {
+			input: pricePerMillion(raw.pricing?.input),
+			output: pricePerMillion(raw.pricing?.output),
+			cacheRead: pricePerMillion(raw.pricing?.input_cache_read),
+			cacheWrite: 0
+		},
+		contextWindow: raw.context_window ?? 128e3,
+		maxTokens: raw.max_tokens ?? 8192
+	};
+}
+const gatewayModelCache = /* @__PURE__ */ new Map();
+const gatewayModelPending = /* @__PURE__ */ new Map();
+function gatewayModelCacheKey(modelId, baseUrl) {
+	return `${resolveGatewayOrigin(baseUrl)}::${modelId}`;
+}
+function readCachedGatewayModel(cacheKey) {
+	const entry = gatewayModelCache.get(cacheKey);
+	if (!entry) return { cached: false };
+	return {
+		cached: true,
+		model: entry.status === "found" ? entry.model : void 0
+	};
+}
+function writeCachedGatewayModel(cacheKey, model) {
+	gatewayModelCache.set(cacheKey, model ? {
+		status: "found",
+		model
+	} : { status: "missing" });
+}
+async function fetchGatewayModel(modelId, baseUrl) {
+	const cacheKey = gatewayModelCacheKey(modelId, baseUrl);
+	const cached = readCachedGatewayModel(cacheKey);
+	if (cached.cached) return cached.model;
+	const pending = gatewayModelPending.get(cacheKey);
+	if (pending) return pending;
+	const request = (async () => {
+		const gatewayApiKey = process.env.AI_GATEWAY_API_KEY?.trim();
+		const headers = {};
+		if (gatewayApiKey) headers.authorization = `Bearer ${gatewayApiKey}`;
+		const url = `${resolveGatewayOrigin(baseUrl)}/v1/models/${modelId}`;
+		try {
+			const response = await fetch(url, { headers });
+			if (!response.ok) {
+				writeCachedGatewayModel(cacheKey, void 0);
+				return;
+			}
+			const raw = parseGatewayModelResponse(await response.json());
+			if (!raw) {
+				writeCachedGatewayModel(cacheKey, void 0);
+				return;
+			}
+			const model = buildGatewayModel(raw, baseUrl);
+			writeCachedGatewayModel(cacheKey, model);
+			return model;
+		} catch {
+			writeCachedGatewayModel(cacheKey, void 0);
+			return;
+		} finally {
+			gatewayModelPending.delete(cacheKey);
+		}
+	})();
+	gatewayModelPending.set(cacheKey, request);
+	return request;
+}
+async function resolveGatewayModel(modelId) {
+	const baseUrl = resolveGatewayBaseUrl();
 	for (const candidate of agentModelIdCandidates(modelId)) {
 		const registered = getModelLoose("vercel-ai-gateway", candidate);
 		if (registered) {
-			const baseUrl = resolveGatewayBaseUrl();
 			if (!baseUrl) return registered;
 			return {
 				...registered,
@@ -5371,6 +5474,10 @@ function resolveGatewayModel(modelId) {
 			};
 		}
 	}
+	for (const candidate of agentModelIdCandidates(modelId)) {
+		const fetched = await fetchGatewayModel(candidate, baseUrl);
+		if (fetched) return fetched;
+	}
 	throw new Error(`Unknown gateway model: ${modelId}`);
 }
 function resolveDirectModel(modelId) {
@@ -5382,7 +5489,7 @@ function resolveDirectModel(modelId) {
 	throw new Error(`Unknown model: ${modelId}`);
 }
 /** Resolve a user-authored model id to a pi-ai {@link Model} for the current runtime env. */
-function resolveAgentModel(modelId) {
+async function resolveAgentModel(modelId) {
 	if (shouldUseGatewayTransport()) return resolveGatewayModel(modelId);
 	return resolveDirectModel(modelId);
 }
@@ -13940,7 +14047,7 @@ function normalizeTitle(raw) {
 async function generateSessionTitle(message) {
 	const input = message.trim();
 	if (!input) return null;
-	return normalizeTitle((await completeSimple(resolveAgentModel(TITLE_MODEL_ID), {
+	return normalizeTitle((await completeSimple(await resolveAgentModel(TITLE_MODEL_ID), {
 		systemPrompt: TITLE_SYSTEM_PROMPT,
 		messages: [{
 			role: "user",
@@ -14351,7 +14458,7 @@ async function buildAgentRuntime(def, ctx, runPrompt = {}, agentSlug) {
 	return {
 		...createAgent({
 			systemPrompt,
-			model: resolveAgentModel(def.model),
+			model: await resolveAgentModel(def.model),
 			thinkingLevel,
 			messages: ctx.messages,
 			tools
@@ -14529,7 +14636,7 @@ const RESPOND_TOOL_NAME = "respond";
 const STRUCTURED_OUTPUT_INSTRUCTION = "Respond only by calling `respond` with arguments matching the schema; do not answer in plain text.";
 const MAX_OBJECT_ATTEMPTS = 3;
 /** Same validation as `defineAgent` — format check before catalog lookup. */
-function resolvePromptModel(model) {
+async function resolvePromptModel(model) {
 	return resolveAgentModel(AgentModelIdSchema.parse(model));
 }
 /**
@@ -14580,7 +14687,7 @@ async function recordUsageFromMessage(message, hooks) {
 	if (usage) await hooks?.onUsage?.(usage);
 }
 async function runPromptText(opts, hooks) {
-	const model = resolvePromptModel(opts.model);
+	const model = await resolvePromptModel(opts.model);
 	const reasoning = resolvePromptReasoning(opts.thinkingLevel);
 	const message = await completeSimple(model, {
 		systemPrompt: opts.system,
@@ -14601,7 +14708,7 @@ async function runPromptText(opts, hooks) {
 async function runPromptObject(opts, hooks) {
 	const schema = opts.outputSchema;
 	if (!schema) throw new Error("outputSchema is required for structured LLM output");
-	const model = resolvePromptModel(opts.model);
+	const model = await resolvePromptModel(opts.model);
 	const reasoning = resolvePromptReasoning(opts.thinkingLevel);
 	const { toolSchema, unwrap } = wrapSchemaForTool(schema);
 	const tool = buildRespondTool(toolSchema);