pi-commandcode-provider 0.4.3 → 0.5.0

package/src/json-schema.ts

@@ -0,0 +1,382 @@
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined
+}
+
+function booleanValue(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined
+}
+
+type JsonSchemaValue = boolean | Record<string, unknown>
+
+const JSON_SCHEMA_TYPES = new Set([
+  "array",
+  "boolean",
+  "integer",
+  "null",
+  "number",
+  "object",
+  "string",
+])
+
+const LEGACY_KINDS = new Set([
+  "any",
+  "array",
+  "boolean",
+  "enum",
+  "integer",
+  "intersect",
+  "intersection",
+  "literal",
+  "never",
+  "null",
+  "nullable",
+  "number",
+  "object",
+  "optional",
+  "string",
+  "undefined",
+  "union",
+  "unknown",
+])
+
+const LEGACY_FIELDS = new Set([
+  "element",
+  "kind",
+  "inner",
+  "optional",
+  "value",
+  "values",
+  "variants",
+  "wrapped",
+])
+
+const SCHEMA_MAP_FIELDS = new Set([
+  "$defs",
+  "definitions",
+  "dependentSchemas",
+  "patternProperties",
+  "properties",
+])
+
+const SCHEMA_ARRAY_FIELDS = new Set(["allOf", "anyOf", "oneOf", "prefixItems"])
+
+const SCHEMA_VALUE_FIELDS = new Set([
+  "additionalItems",
+  "additionalProperties",
+  "contains",
+  "contentSchema",
+  "else",
+  "if",
+  "items",
+  "not",
+  "propertyNames",
+  "then",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+])
+
+const SCHEMA_KEYWORDS = new Set([
+  "$anchor",
+  "$comment",
+  "$defs",
+  "$dynamicAnchor",
+  "$dynamicRef",
+  "$id",
+  "$ref",
+  "$schema",
+  "$vocabulary",
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "const",
+  "contains",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "default",
+  "definitions",
+  "dependentRequired",
+  "dependentSchemas",
+  "description",
+  "else",
+  "enum",
+  "examples",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "format",
+  "if",
+  "items",
+  "maxContains",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "maximum",
+  "minContains",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "minimum",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "prefixItems",
+  "properties",
+  "propertyNames",
+  "readOnly",
+  "required",
+  "title",
+  "type",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "uniqueItems",
+  "writeOnly",
+])
+
+function stringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined
+  const values = value.filter((item): item is string => typeof item === "string")
+  return values.length === value.length ? values : undefined
+}
+
+function validSchemaType(value: unknown): boolean {
+  if (typeof value === "string") return JSON_SCHEMA_TYPES.has(value)
+  if (!Array.isArray(value) || value.length === 0) return false
+  return value.every((item) => typeof item === "string" && JSON_SCHEMA_TYPES.has(item))
+}
+
+function legacyKind(schema: Record<string, unknown>): string | undefined {
+  const explicitKind = stringValue(schema.kind)?.toLowerCase()
+  if (explicitKind && LEGACY_KINDS.has(explicitKind)) return explicitKind
+
+  const type = stringValue(schema.type)
+  const normalized = type?.toLowerCase()
+  if (!normalized || !LEGACY_KINDS.has(normalized)) return undefined
+  if (!validSchemaType(type) || Object.keys(schema).some((key) => LEGACY_FIELDS.has(key))) {
+    return normalized
+  }
+  return undefined
+}
+
+function looksLikeJsonSchema(schema: Record<string, unknown>): boolean {
+  if (Object.keys(schema).length === 0) return true
+  if (schema.type !== undefined && !validSchemaType(schema.type)) return false
+  return Object.keys(schema).some((key) => SCHEMA_KEYWORDS.has(key))
+}
+
+function isOptionalSchema(schema: unknown): boolean {
+  if (!isRecord(schema)) return false
+  if (booleanValue(schema.optional) === true) return true
+
+  const kind = legacyKind(schema)
+  if (kind === "optional") return true
+  if (kind !== "union") return false
+
+  const variants = Array.isArray(schema.variants)
+    ? schema.variants
+    : Array.isArray(schema.anyOf)
+      ? schema.anyOf
+      : []
+  return variants.some((variant) => legacyKind(isRecord(variant) ? variant : {}) === "undefined")
+}
+
+function schemaValue(value: unknown, seen: WeakSet<object>): JsonSchemaValue {
+  if (typeof value === "boolean") return value
+  if (!isRecord(value)) return {}
+  return convertSchema(value, seen)
+}
+
+function setSchemaProperty(target: Record<string, unknown>, key: string, value: unknown): void {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true,
+  })
+}
+
+function schemaMap(value: unknown, seen: WeakSet<object>): Record<string, unknown> {
+  if (!isRecord(value)) return {}
+  const out: Record<string, unknown> = {}
+  for (const [key, item] of Object.entries(value)) {
+    setSchemaProperty(out, key, schemaValue(item, seen))
+  }
+  return out
+}
+
+function schemaArray(value: unknown, seen: WeakSet<object>): unknown[] {
+  if (!Array.isArray(value)) return []
+  return value.map((item) => schemaValue(item, seen))
+}
+
+function isSchemaValue(value: unknown): value is JsonSchemaValue {
+  return typeof value === "boolean" || isRecord(value)
+}
+
+function copySchemaObject(
+  source: Record<string, unknown>,
+  seen: WeakSet<object>,
+  legacy: boolean,
+  forcedType?: string,
+): JsonSchemaValue {
+  const out: Record<string, unknown> = {}
+
+  for (const [key, value] of Object.entries(source)) {
+    if (legacy && LEGACY_FIELDS.has(key)) continue
+    if (key === "nullable" || (forcedType !== undefined && key === "type")) continue
+
+    if (key === "required") {
+      const required = stringArray(value)
+      if (required) out.required = required
+    } else if (SCHEMA_MAP_FIELDS.has(key)) {
+      out[key] = schemaMap(value, seen)
+    } else if (SCHEMA_ARRAY_FIELDS.has(key)) {
+      out[key] = schemaArray(value, seen)
+    } else if (SCHEMA_VALUE_FIELDS.has(key)) {
+      out[key] =
+        Array.isArray(value) && key === "items"
+          ? schemaArray(value, seen)
+          : schemaValue(value, seen)
+    } else {
+      out[key] = value
+    }
+  }
+
+  if (forcedType !== undefined) out.type = forcedType
+  if (booleanValue(source.nullable) === true) return makeNullable(out)
+  return out
+}
+
+function makeNullable(schema: Record<string, unknown>): Record<string, unknown> {
+  const type = schema.type
+  if (typeof type === "string") {
+    if (type === "null") return schema
+    return { ...schema, type: [type, "null"] }
+  }
+  if (Array.isArray(type) && !type.includes("null")) {
+    return { ...schema, type: [...type, "null"] }
+  }
+  if (Array.isArray(schema.anyOf)) {
+    return { ...schema, anyOf: [...schema.anyOf, { type: "null" }] }
+  }
+  return { anyOf: [schema, { type: "null" }] }
+}
+
+function legacyVariants(schema: Record<string, unknown>): unknown[] {
+  if (Array.isArray(schema.variants)) return schema.variants
+  if (Array.isArray(schema.anyOf)) return schema.anyOf
+  return []
+}
+
+function convertLegacySchema(
+  source: Record<string, unknown>,
+  kind: string,
+  seen: WeakSet<object>,
+): JsonSchemaValue {
+  if (kind === "optional") return schemaValue(source.wrapped ?? source.inner, seen)
+  if (kind === "nullable") {
+    const wrapped = schemaValue(source.wrapped ?? source.inner, seen)
+    return typeof wrapped === "boolean" ? wrapped : makeNullable(wrapped)
+  }
+  if (kind === "undefined" || kind === "never" || kind === "any" || kind === "unknown") return {}
+
+  if (kind === "union" || kind === "intersect" || kind === "intersection") {
+    const variants = legacyVariants(source)
+      .map((variant) => schemaValue(variant, seen))
+      .filter(
+        (variant) =>
+          isSchemaValue(variant) &&
+          (typeof variant === "boolean" || Object.keys(variant).length > 0),
+      )
+    if (variants.length === 0) return copySchemaObject(source, seen, true)
+    if (variants.length === 1) return variants[0] ?? {}
+
+    const out = copySchemaObject(source, seen, true)
+    if (typeof out !== "boolean") out[kind === "union" ? "anyOf" : "allOf"] = variants
+    return out
+  }
+
+  if (kind === "object") {
+    const converted = copySchemaObject(source, seen, true, "object")
+    if (typeof converted === "boolean") return converted
+    const out = converted
+    const sourceProperties = isRecord(source.properties) ? source.properties : undefined
+    if (!sourceProperties) return out
+
+    const properties: Record<string, unknown> = {}
+    const optional = stringArray(source.optional) ?? []
+    for (const [key, value] of Object.entries(sourceProperties)) {
+      setSchemaProperty(properties, key, schemaValue(value, seen))
+    }
+    out.properties = properties
+
+    const explicitRequired = stringArray(source.required)
+    const required =
+      explicitRequired ??
+      Object.entries(sourceProperties)
+        .filter(([key, value]) => !optional.includes(key) && !isOptionalSchema(value))
+        .map(([key]) => key)
+    if (required.length > 0) out.required = required
+    else delete out.required
+    return out
+  }
+
+  if (kind === "array") {
+    const converted = copySchemaObject(source, seen, true, "array")
+    if (typeof converted === "boolean") return converted
+    const out = converted
+    if (!("items" in source) && "element" in source) out.items = schemaValue(source.element, seen)
+    return out
+  }
+
+  if (kind === "enum") {
+    const converted = copySchemaObject(source, seen, true)
+    if (typeof converted === "boolean") return converted
+    const out = converted
+    if (!("enum" in out) && Array.isArray(source.values)) out.enum = source.values
+    return out
+  }
+
+  if (kind === "literal") {
+    const converted = copySchemaObject(source, seen, true)
+    if (typeof converted === "boolean") return converted
+    const out = converted
+    if (!("const" in out) && "value" in source) out.const = source.value
+    return out
+  }
+
+  const scalarType =
+    kind === "string" ||
+    kind === "number" ||
+    kind === "boolean" ||
+    kind === "integer" ||
+    kind === "null"
+      ? kind
+      : undefined
+  return scalarType ? copySchemaObject(source, seen, true, scalarType) : {}
+}
+
+function convertSchema(source: Record<string, unknown>, seen: WeakSet<object>): JsonSchemaValue {
+  if (seen.has(source)) return {}
+  seen.add(source)
+  try {
+    const kind = legacyKind(source)
+    if (kind) return convertLegacySchema(source, kind, seen)
+    if (!looksLikeJsonSchema(source)) return {}
+    return copySchemaObject(source, seen, false)
+  } finally {
+    seen.delete(source)
+  }
+}
+
+export function toJsonSchema(schema: unknown): unknown {
+  if (typeof schema === "boolean") return schema
+  if (!isRecord(schema)) return {}
+  return convertSchema(schema, new WeakSet<object>())
+}

package/src/models.ts

@@ -2,10 +2,97 @@ import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises"
 import { dirname } from "node:path"
 
 export const DEFAULT_MODELS_URL = "https://api.commandcode.ai/provider/v1/models"
+export const DEFAULT_MODELS_TIMEOUT_MS = 10_000
 
 const DEFAULT_MAX_OUTPUT_TOKENS = 65_536
 const MODEL_CACHE_VERSION = 1
 
+export type PiThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
+
+type CommandCodeReasoningEffort = Exclude<PiThinkingLevel, "off">
+
+/**
+ * Per-model reasoning efforts supported by Command Code's generate endpoint.
+ *
+ * The Provider API does not expose reasoning metadata. This is an exact
+ * snapshot of `reasoningEfforts` from the command-code@1.14.1 model catalog
+ * (`packages/shared/src/model-catalog.ts`, also published in the generated
+ * `dist/bundled/command-code-knowledge/reference/models.md`). Models omitted
+ * here let Command Code choose their reasoning depth, matching the CLI.
+ */
+export const MODEL_EFFORTS: Readonly<Record<string, readonly CommandCodeReasoningEffort[]>> = {
+  "Qwen/Qwen3.8-Max": ["low", "medium", "xhigh"],
+  "claude-fable-5": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-7": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-4-8": ["low", "medium", "high", "xhigh", "max"],
+  "claude-opus-5": ["low", "medium", "high", "xhigh", "max"],
+  "claude-sonnet-4-6": ["low", "medium", "high", "xhigh", "max"],
+  "claude-sonnet-5": ["low", "medium", "high", "xhigh", "max"],
+  "deepseek/deepseek-v4-flash": ["high", "max"],
+  "deepseek/deepseek-v4-pro": ["high", "max"],
+  "gpt-5.3-codex": ["low", "medium", "high", "xhigh"],
+  "gpt-5.4": ["low", "medium", "high", "xhigh"],
+  "gpt-5.4-mini": ["low", "medium", "high"],
+  "gpt-5.5": ["low", "medium", "high", "xhigh"],
+  "gpt-5.6-luna": ["low", "medium", "high", "xhigh", "max"],
+  "gpt-5.6-sol": ["low", "medium", "high", "xhigh", "max"],
+  "gpt-5.6-terra": ["low", "medium", "high", "xhigh", "max"],
+  "google/gemini-3.1-flash-lite": ["low", "medium", "high"],
+  "google/gemini-3.5-flash": ["low", "medium", "high"],
+  "google/gemini-3.5-flash-lite": ["low", "medium", "high"],
+  "google/gemini-3.6-flash": ["low", "medium", "high"],
+  "sakana/fugu-ultra": ["high", "xhigh"],
+  "xai/grok-4.5": ["low", "medium", "high"],
+  "zai-org/GLM-5.2": ["high", "max"],
+}
+
+const PI_THINKING_LEVELS: readonly PiThinkingLevel[] = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+]
+
+export function thinkingLevelMapForEfforts(
+  efforts: readonly string[],
+): Partial<Record<PiThinkingLevel, string | null>> {
+  const map: Partial<Record<PiThinkingLevel, string | null>> = {}
+  for (const level of PI_THINKING_LEVELS) {
+    if (level === "off") continue
+    map[level] = efforts.includes(level) ? level : null
+  }
+  return map
+}
+
+export interface ThinkingMetadata {
+  thinkingLevelMap: Partial<Record<PiThinkingLevel, string | null>>
+  thinking: {
+    mode: "effort"
+    effortMap: Partial<Record<CommandCodeReasoningEffort, string>>
+    efforts: readonly CommandCodeReasoningEffort[]
+  }
+}
+
+export function thinkingMetadataForModel(modelId: string): ThinkingMetadata | undefined {
+  const efforts = MODEL_EFFORTS[modelId]
+  if (!efforts) return undefined
+  return {
+    thinkingLevelMap: thinkingLevelMapForEfforts(efforts),
+    thinking: {
+      mode: "effort",
+      effortMap: Object.fromEntries(efforts.map((effort) => [effort, effort])),
+      efforts,
+    },
+  }
+}
+
+function isReasoningModel(modelId: string): boolean {
+  return MODEL_EFFORTS[modelId] !== undefined
+}
+
 interface ApiModel {
   id: string
   name: string
@@ -23,6 +110,8 @@ export interface CommandCodeModel {
 interface FetchCommandCodeModelsOptions {
   url?: string
   fetchImpl?: typeof fetch
+  signal?: AbortSignal
+  timeoutMs?: number
 }
 
 interface LoadCommandCodeModelsOptions extends FetchCommandCodeModelsOptions {
@@ -74,10 +163,12 @@ function parseApiModel(value: unknown): ApiModel {
 function parseCachedModel(value: unknown): CommandCodeModel {
   if (!isRecord(value)) throw new Error("Expected cached model entry to be an object")
 
+  const id = stringField(value, "id")
+  booleanField(value, "reasoning")
   return {
-    id: stringField(value, "id"),
+    id,
     name: stringField(value, "name"),
-    reasoning: booleanField(value, "reasoning"),
+    reasoning: isReasoningModel(id),
     contextWindow: positiveNumberField(value, "contextWindow"),
     maxTokens: positiveNumberField(value, "maxTokens"),
   }
@@ -92,6 +183,85 @@ function errorMessage(error: unknown): string {
   return error instanceof Error ? error.message : String(error)
 }
 
+function abortError(reason: unknown): Error {
+  if (reason instanceof Error) return reason
+  return new DOMException("The operation was aborted", "AbortError")
+}
+
+function configuredTimeoutMs(timeoutMs: number | undefined): number {
+  return timeoutMs !== undefined && Number.isFinite(timeoutMs) && timeoutMs > 0
+    ? timeoutMs
+    : DEFAULT_MODELS_TIMEOUT_MS
+}
+
+export function getModelsTimeoutMs(env: NodeJS.ProcessEnv = process.env): number {
+  const raw = env.COMMANDCODE_MODELS_TIMEOUT_MS
+  if (!raw) return DEFAULT_MODELS_TIMEOUT_MS
+
+  const parsed = Number(raw)
+  return configuredTimeoutMs(parsed)
+}
+
+class ModelDiscoveryTimeoutError extends Error {
+  constructor(timeoutMs: number) {
+    super(`Command Code model discovery timed out after ${timeoutMs}ms`)
+    this.name = "ModelDiscoveryTimeoutError"
+  }
+}
+
+function runWithTimeout<T>(
+  operation: (signal: AbortSignal) => Promise<T>,
+  timeoutMs: number,
+  externalSignal: AbortSignal | undefined,
+): Promise<T> {
+  const controller = new AbortController()
+  let timer: ReturnType<typeof setTimeout> | undefined
+  let settled = false
+  let onExternalAbort: (() => void) | undefined
+
+  return new Promise<T>((resolve, reject) => {
+    const cleanup = () => {
+      if (timer !== undefined) clearTimeout(timer)
+      if (onExternalAbort && externalSignal) {
+        externalSignal.removeEventListener("abort", onExternalAbort)
+      }
+    }
+
+    const resolveOnce = (value: T) => {
+      if (settled) return
+      settled = true
+      cleanup()
+      resolve(value)
+    }
+
+    const rejectOnce = (error: unknown) => {
+      if (settled) return
+      settled = true
+      cleanup()
+      reject(error)
+    }
+
+    const abort = (reason: unknown) => {
+      const error = abortError(reason)
+      controller.abort(error)
+      rejectOnce(error)
+    }
+
+    if (externalSignal?.aborted) {
+      abort(externalSignal.reason)
+      return
+    }
+
+    onExternalAbort = () => abort(externalSignal?.reason)
+    externalSignal?.addEventListener("abort", onExternalAbort, { once: true })
+    timer = setTimeout(() => abort(new ModelDiscoveryTimeoutError(timeoutMs)), timeoutMs)
+
+    Promise.resolve()
+      .then(() => operation(controller.signal))
+      .then(resolveOnce, rejectOnce)
+  })
+}
+
 export function commandCodeModelsFromApiResponse(value: unknown): readonly CommandCodeModel[] {
   if (!isRecord(value)) throw new Error("Expected models response to be an object")
   if (value.object !== "list") throw new Error("Expected models response object to be 'list'")
@@ -102,7 +272,7 @@ export function commandCodeModelsFromApiResponse(value: unknown): readonly Comma
   return data.map(parseApiModel).map((model) => ({
     id: model.id,
     name: `${model.name} (CC)`,
-    reasoning: true,
+    reasoning: isReasoningModel(model.id),
     contextWindow: model.contextLength,
     maxTokens: Math.min(model.contextLength, DEFAULT_MAX_OUTPUT_TOKENS),
   }))
@@ -123,19 +293,26 @@ export async function fetchCommandCodeModels(
 ): Promise<readonly CommandCodeModel[]> {
   const url = options.url ?? DEFAULT_MODELS_URL
   const fetchImpl = options.fetchImpl ?? fetch
-  const response = await fetchImpl(url, {
-    headers: {
-      accept: "application/json",
-    },
-  })
+  const body: unknown = await runWithTimeout(
+    async (signal) => {
+      const response = await fetchImpl(url, {
+        headers: {
+          accept: "application/json",
+        },
+        signal,
+      })
 
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch Command Code models: ${response.status} ${response.statusText}`,
-    )
-  }
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch Command Code models: ${response.status} ${response.statusText}`,
+        )
+      }
 
-  const body: unknown = await response.json()
+      return await response.json()
+    },
+    configuredTimeoutMs(options.timeoutMs),
+    options.signal,
+  )
   return requireModels(commandCodeModelsFromApiResponse(body))
 }
 
@@ -187,6 +364,8 @@ export async function loadCommandCodeModels(
       }
     }
   } catch (liveError) {
+    if (options.signal?.aborted) throw abortError(options.signal.reason ?? liveError)
+
     try {
       const models = await readCommandCodeModelsCache(cachePath)
       return {
@@ -198,7 +377,7 @@ export async function loadCommandCodeModels(
       return {
         models: [],
         source: "empty",
-        warning: `Could not refresh the Command Code model catalog (${errorMessage(liveError)}), and no valid cached catalog is available at ${cachePath} (${errorMessage(cacheError)}). Command Code models will remain unavailable until /reload succeeds.`,
+        warning: `Could not refresh the Command Code model catalog (${errorMessage(liveError)}), and no valid cached catalog is available at ${cachePath} (${errorMessage(cacheError)}). Command Code models will remain unavailable until /commandcode-refresh succeeds.`,
       }
     }
   }