pi-commandcode-provider 0.4.3 → 0.5.1

package/scripts/pi-isolated.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process"
+import { mkdir, mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { dirname, join, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..")
+const testRoot = await mkdtemp(join(tmpdir(), "pi-commandcode-isolated-"))
+const agentDir = join(testRoot, "agent")
+const sessionDir = join(testRoot, "sessions")
+
+await mkdir(agentDir, { mode: 0o700 })
+await mkdir(sessionDir, { mode: 0o700 })
+
+const env = {
+  ...process.env,
+  HOME: testRoot,
+  USERPROFILE: testRoot,
+  PI_CODING_AGENT_DIR: agentDir,
+  PI_CODING_AGENT_SESSION_DIR: sessionDir,
+  PI_SKIP_VERSION_CHECK: "1",
+}
+delete env.COMMANDCODE_API_KEY
+
+let activeChild
+let receivedSignal
+
+function forwardSignal(signal) {
+  receivedSignal = signal
+  activeChild?.kill(signal)
+}
+
+const forwardSigint = () => forwardSignal("SIGINT")
+const forwardSigterm = () => forwardSignal("SIGTERM")
+process.on("SIGINT", forwardSigint)
+process.on("SIGTERM", forwardSigterm)
+
+function runPi(args) {
+  return new Promise((resolveRun, rejectRun) => {
+    const child = spawn("pi", args, { cwd: repoRoot, env, stdio: "inherit" })
+    activeChild = child
+    child.once("error", rejectRun)
+    child.once("exit", (status, signal) => {
+      activeChild = undefined
+      resolveRun({ status, signal })
+    })
+  })
+}
+
+let result
+try {
+  console.error("Installing the current checkout into an isolated pi environment...")
+  const install = await runPi(["install", repoRoot, "--no-approve"])
+  if (install.status !== 0 || install.signal) {
+    result = install
+  } else {
+    console.error("Starting pi. Temporary auth and sessions will be removed on exit.")
+    result = await runPi([
+      "--no-approve",
+      "--provider",
+      "commandcode",
+      "--model",
+      "gpt-5.6-luna",
+      ...process.argv.slice(2),
+    ])
+  }
+} finally {
+  process.removeListener("SIGINT", forwardSigint)
+  process.removeListener("SIGTERM", forwardSigterm)
+  await rm(testRoot, { recursive: true, force: true })
+  console.error("Removed the isolated pi environment.")
+}
+
+const signal = receivedSignal ?? result?.signal
+if (signal) process.kill(process.pid, signal)
+process.exitCode = result?.status ?? 1

package/src/converters.ts

@@ -3,6 +3,9 @@ import { homedir } from "node:os"
 import { join } from "node:path"
 
 import type { MessageLike, StopReason, ToolLike } from "./types.ts"
+import { toJsonSchema } from "./json-schema.ts"
+
+export { toJsonSchema } from "./json-schema.ts"
 
 export function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value)
@@ -12,10 +15,6 @@ export function stringValue(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined
 }
 
-function booleanValue(value: unknown): boolean | undefined {
-  return typeof value === "boolean" ? value : undefined
-}
-
 export function recordArray(value: unknown): readonly Record<string, unknown>[] {
   if (!Array.isArray(value)) return []
   return value.filter(isRecord)
@@ -56,6 +55,50 @@ function apiKeyFromCredentialRecord(value: unknown): string | undefined {
   return stringValue(value.key) ?? stringValue(value.access)
 }
 
+function imageParts(value: unknown): readonly Record<string, unknown>[] {
+  if (isRecord(value)) return value.type === "image" ? [value] : []
+  return recordArray(value).filter((part) => part.type === "image")
+}
+
+function imageContentError(role: string): Error {
+  return new Error(`Selected Command Code model does not support image content in ${role}`)
+}
+
+export function assertTextOnlyMessages(messages?: readonly MessageLike[]): void {
+  for (const message of messages ?? []) {
+    if (imageParts(message.content).length > 0) {
+      const role = message.role === "toolResult" ? "tool results" : `${message.role} messages`
+      throw imageContentError(role)
+    }
+  }
+}
+
+function imageToCommandCode(part: Record<string, unknown>): Record<string, string> {
+  const data = stringValue(part.data)
+  const mimeType = stringValue(part.mimeType)
+  if (!data || !mimeType)
+    throw new Error("Invalid image content: expected base64 data and mimeType")
+
+  return {
+    type: "image",
+    image: `data:${mimeType};base64,${data}`,
+    mimeType,
+  }
+}
+
+function userContentToCommandCode(content: unknown, allowImages: boolean): unknown {
+  if (typeof content === "string") return content
+
+  return recordArray(content).flatMap((part) => {
+    if (part.type === "text") return [{ type: "text", text: stringValue(part.text) ?? "" }]
+    if (part.type === "image") {
+      if (!allowImages) throw imageContentError("user messages")
+      return [imageToCommandCode(part)]
+    }
+    return []
+  })
+}
+
 export function getApiKey(
   options: {
     env?: NodeJS.ProcessEnv
@@ -106,80 +149,6 @@ export function getEnvironmentInfo(): string {
   return `${process.platform}-${process.arch}, Node.js ${process.version}`
 }
 
-export function toJsonSchema(schema: unknown): unknown {
-  if (!isRecord(schema)) return {}
-
-  const kind = stringValue(schema.kind) ?? stringValue(schema.type)
-  const enumValues = Array.isArray(schema.enum) ? schema.enum : undefined
-  if (enumValues) {
-    return { type: typeof enumValues[0], enum: enumValues }
-  }
-
-  switch (kind) {
-    case "string":
-    case "String":
-      return { type: "string" }
-    case "number":
-    case "Number":
-      return { type: "number" }
-    case "boolean":
-    case "Boolean":
-      return { type: "boolean" }
-    case "object":
-    case "Object": {
-      const properties: Record<string, unknown> = {}
-      const inferredRequired: string[] = []
-      const sourceProperties = isRecord(schema.properties) ? schema.properties : undefined
-      const optional = Array.isArray(schema.optional)
-        ? schema.optional.filter((item): item is string => typeof item === "string")
-        : []
-
-      if (sourceProperties) {
-        for (const [key, value] of Object.entries(sourceProperties)) {
-          properties[key] = toJsonSchema(value)
-          const valueRecord = isRecord(value) ? value : undefined
-          if (booleanValue(valueRecord?.optional) !== true && !optional.includes(key)) {
-            inferredRequired.push(key)
-          }
-        }
-      }
-
-      const explicitRequired = Array.isArray(schema.required)
-        ? schema.required.filter((item): item is string => typeof item === "string")
-        : undefined
-      const required = explicitRequired ?? inferredRequired
-      const out: Record<string, unknown> = { type: "object" }
-      if (Object.keys(properties).length > 0) out.properties = properties
-      if (required.length > 0) out.required = required
-      return out
-    }
-    case "array":
-    case "Array":
-      return {
-        type: "array",
-        items: toJsonSchema(schema.items ?? schema.element),
-      }
-    case "union":
-    case "Union": {
-      const variants = Array.isArray(schema.variants)
-        ? schema.variants
-        : Array.isArray(schema.anyOf)
-          ? schema.anyOf
-          : []
-      for (const variant of variants) {
-        const converted = toJsonSchema(variant)
-        if (isRecord(converted) && Object.keys(converted).length > 0) return converted
-      }
-      return {}
-    }
-    case "optional":
-    case "Optional":
-      return toJsonSchema(schema.wrapped ?? schema.inner)
-    default:
-      return {}
-  }
-}
-
 export function toolsToJson(tools?: readonly ToolLike[]): unknown[] {
   if (!tools) return []
   return tools.map((tool) => ({
@@ -210,7 +179,13 @@ function completeToolCallIds(messages?: readonly MessageLike[]): Set<string> {
   return new Set([...callIds].filter((id) => resultIds.has(id)))
 }
 
-export function messagesToCC(messages?: readonly MessageLike[]): unknown[] {
+export function messagesToCC(
+  messages?: readonly MessageLike[],
+  options: { allowImages?: boolean } = {},
+): unknown[] {
+  const allowImages = options.allowImages ?? false
+  if (!allowImages) assertTextOnlyMessages(messages)
+
   const out: unknown[] = []
   const pairedToolCallIds = completeToolCallIds(messages)
 
@@ -218,18 +193,13 @@ export function messagesToCC(messages?: readonly MessageLike[]): unknown[] {
     if (message.role === "user") {
       out.push({
         role: "user",
-        content: typeof message.content === "string" ? message.content : message.content,
+        content: userContentToCommandCode(message.content, allowImages),
       })
     } else if (message.role === "assistant") {
       const parts: unknown[] = []
       for (const content of recordArray(message.content)) {
         if (content.type === "text") {
           parts.push({ type: "text", text: stringValue(content.text) ?? "" })
-        } else if (content.type === "thinking") {
-          parts.push({
-            type: "reasoning",
-            text: stringValue(content.thinking) ?? "",
-          })
         } else if (content.type === "toolCall") {
           const toolCallId = stringValue(content.id) ?? ""
           if (!pairedToolCallIds.has(toolCallId)) continue
@@ -257,6 +227,15 @@ export function messagesToCC(messages?: readonly MessageLike[]): unknown[] {
           },
         ],
       })
+
+      const images = imageParts(message.content)
+      if (images.length > 0) {
+        if (!allowImages) throw imageContentError("tool results")
+        out.push({
+          role: "user",
+          content: images.map(imageToCommandCode),
+        })
+      }
     }
   }
   return out

package/src/core.ts

@@ -7,10 +7,13 @@
 
 import { randomUUID } from "node:crypto"
 
+import { commandCodeErrorMessage, redactCommandCodeErrorText } from "./overflow.ts"
+import { modelSupportsImageInput } from "./models.ts"
 import {
   getApiKey,
   getEnvironmentInfo,
   isRecord,
+  assertTextOnlyMessages,
   mapFinishReason,
   messagesToCC,
   numberValue,
@@ -36,10 +39,11 @@ import type {
 } from "./types.ts"
 
 export * from "./converters.ts"
+export * from "./overflow.ts"
 export * from "./types.ts"
 
 export const DEFAULT_API_BASE = "https://api.commandcode.ai"
-export const COMMAND_CODE_CLI_VERSION = "0.29.0"
+export const COMMAND_CODE_CLI_VERSION = "1.15.1"
 
 const DEFAULT_GENERATE_MAX_TOKENS = 64_000
 const DEFAULT_MAX_RETRIES = 0
@@ -134,6 +138,15 @@ function generateMaxTokens(model: ModelLike, options?: StreamOptions): number {
   )
 }
 
+function mappedReasoningEffort(model: ModelLike, options?: StreamOptions): string | undefined {
+  const level = options?.reasoning
+  if (!level || level === "off" || !model.reasoning) return undefined
+
+  const effortMap = model.thinking?.effortMap ?? model.thinkingLevelMap
+  const mapped = effortMap?.[level]
+  return typeof mapped === "string" && mapped !== "off" ? mapped : undefined
+}
+
 export function projectSlugFromPath(pathName: string): string {
   const slug = pathName
     .toLowerCase()
@@ -185,6 +198,31 @@ export function createStreamCommandCode(deps: CoreDependencies) {
     })
   }
 
+  function raceAbortWithTimeout<T>(
+    promise: Promise<T>,
+    controller: AbortController,
+    timeoutMs: number | undefined,
+  ): Promise<T> {
+    if (timeoutMs === undefined) return raceAbort(promise, controller.signal)
+
+    return new Promise<T>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        controller.abort()
+        reject(timeoutError(timeoutMs))
+      }, timeoutMs)
+      raceAbort(promise, controller.signal).then(
+        (value) => {
+          clearTimeout(timer)
+          resolve(value)
+        },
+        (error: unknown) => {
+          clearTimeout(timer)
+          reject(error)
+        },
+      )
+    })
+  }
+
   return function streamCommandCode(
     model: ModelLike,
     context: ContextLike,
@@ -388,10 +426,14 @@ export function createStreamCommandCode(deps: CoreDependencies) {
             const usage = commandCodeUsage(event)
             if (usage) {
               const details = commandCodeInputTokenDetails(usage)
-              output.usage.input = numberValue(usage.inputTokens) ?? 0
+              const totalInput = numberValue(usage.inputTokens) ?? 0
+              const input = numberValue(details?.noCacheTokens)
+              const cacheRead = numberValue(details?.cacheReadTokens) ?? 0
+              const cacheWrite = numberValue(details?.cacheWriteTokens) ?? 0
+              output.usage.input = input ?? Math.max(0, totalInput - cacheRead - cacheWrite)
               output.usage.output = numberValue(usage.outputTokens) ?? 0
-              output.usage.cacheRead = numberValue(details?.cacheReadTokens) ?? 0
-              output.usage.cacheWrite = numberValue(details?.cacheWriteTokens) ?? 0
+              output.usage.cacheRead = cacheRead
+              output.usage.cacheWrite = cacheWrite
               output.usage.totalTokens =
                 output.usage.input +
                 output.usage.output +
@@ -405,9 +447,10 @@ export function createStreamCommandCode(deps: CoreDependencies) {
           }
 
           case "error": {
-            const errorRecord = isRecord(event.error) ? event.error : undefined
             const message =
-              stringValue(errorRecord?.message) ?? stringValue(event.error) ?? "Stream error"
+              commandCodeErrorMessage(event.error) ??
+              commandCodeErrorMessage(event.message) ??
+              "Stream error"
             output.stopReason = "error"
             output.errorMessage = message
             throw new Error(message)
@@ -417,9 +460,15 @@ export function createStreamCommandCode(deps: CoreDependencies) {
 
       try {
         stream.push({ type: "start", partial: output })
+        if (controller.signal.aborted) throw abortError("Aborted")
 
         const workingDir = cwd()
         const threadId = uuid()
+        const reasoningEffort = mappedReasoningEffort(model, options)
+        const timeoutMs = options?.timeoutMs
+
+        const allowImages = modelSupportsImageInput(model.id)
+        if (!allowImages) assertTextOnlyMessages(context.messages)
 
         let body: unknown = {
           config: {
@@ -438,25 +487,34 @@ export function createStreamCommandCode(deps: CoreDependencies) {
           skills: null,
           params: {
             model: model.id,
-            messages: messagesToCC(context.messages),
+            messages: messagesToCC(context.messages, { allowImages }),
             tools: toolsToJson(context.tools),
             system: systemPromptToText(context.systemPrompt),
             max_tokens: generateMaxTokens(model, options),
             temperature: 0.3,
             stream: true,
+            ...(reasoningEffort ? { reasoning_effort: reasoningEffort } : {}),
           },
           threadId,
         }
 
-        const nextBody = await raceAbort(
-          Promise.resolve(options?.onPayload?.(body, model)),
-          controller.signal,
-        )
+        const payloadController = new AbortController()
+        const onPayloadAbort = () => payloadController.abort()
+        controller.signal.addEventListener("abort", onPayloadAbort, { once: true })
+        let nextBody: unknown
+        try {
+          nextBody = await raceAbortWithTimeout(
+            Promise.resolve(options?.onPayload?.(body, model)),
+            payloadController,
+            timeoutMs,
+          )
+        } finally {
+          controller.signal.removeEventListener("abort", onPayloadAbort)
+        }
         if (nextBody !== undefined) body = nextBody
 
         const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES
         const maxRetryDelayMs = effectiveMaxRetryDelayMs(options?.maxRetryDelayMs)
-        const timeoutMs = options?.timeoutMs
         const requestHeaders = {
           "Content-Type": "application/json",
           Authorization: `Bearer ${apiKey}`,
@@ -490,6 +548,11 @@ export function createStreamCommandCode(deps: CoreDependencies) {
           }
           const onOuterAbort = () => attemptController.abort()
           controller.signal.addEventListener("abort", onOuterAbort, { once: true })
+          const raceAttempt = <T>(promise: Promise<T>): Promise<T> =>
+            raceAbort(promise, attemptController.signal).catch((error: unknown) => {
+              if (attemptTimedOut) throw timeoutError(timeoutMs)
+              throw error
+            })
 
           try {
             try {
@@ -525,25 +588,38 @@ export function createStreamCommandCode(deps: CoreDependencies) {
               }
             }
 
-            await raceAbort(
-              Promise.resolve(
-                options?.onResponse?.(
-                  {
-                    status: response.status,
-                    headers: headersToRecord(response.headers),
-                  },
-                  model,
+            try {
+              await raceAttempt(
+                Promise.resolve(
+                  options?.onResponse?.(
+                    {
+                      status: response.status,
+                      headers: headersToRecord(response.headers),
+                    },
+                    model,
+                  ),
                 ),
-              ),
-              controller.signal,
-            )
+              )
+            } catch (error: unknown) {
+              if (attemptTimedOut && attempt < maxRetries) continue retryLoop
+              throw error
+            }
 
             if (!response.ok) {
-              const errBody = await raceAbort(
-                response.text().catch(() => ""),
-                controller.signal,
+              const errBody = await raceAttempt(response.text().catch(() => ""))
+              let errorDetail: string | undefined
+              try {
+                const parsedBody: unknown = JSON.parse(errBody)
+                errorDetail = commandCodeErrorMessage(parsedBody)
+              } catch {
+                // Preserve useful plain-text provider errors only after secret
+                // redaction; upstream/proxy bodies may echo credentials.
+              }
+              const safeBody = redactCommandCodeErrorText(errBody).slice(0, 500)
+              const detail = redactCommandCodeErrorText(
+                errorDetail ?? (safeBody || "Provider returned an error"),
               )
-              throw new Error(`Command Code API error ${response.status}: ${errBody.slice(0, 500)}`)
+              throw new Error(`Command Code API error ${response.status}: ${detail}`)
             }
 
             // --- Read response stream ---
@@ -624,9 +700,7 @@ export function createStreamCommandCode(deps: CoreDependencies) {
         output.errorMessage =
           reason === "aborted"
             ? "Request aborted"
-            : error instanceof Error
-              ? error.message
-              : String(error)
+            : redactCommandCodeErrorText(error instanceof Error ? error.message : String(error))
         stream.push({ type: "error", reason, error: output })
         stream.end()
       } finally {
@@ -653,7 +727,9 @@ export function createStreamCommandCode(deps: CoreDependencies) {
         model: model.id,
         usage: defaultUsage(),
         stopReason: "error",
-        errorMessage: error instanceof Error ? error.message : String(error),
+        errorMessage: redactCommandCodeErrorText(
+          error instanceof Error ? error.message : String(error),
+        ),
         timestamp: now(),
       }
       stream.push({ type: "error", reason: "error", error: msg })

package/src/cost.ts

@@ -10,10 +10,22 @@
 import type { ModelLike, Usage } from "./types.ts"
 
 export function calculateCommandCodeCost(model: ModelLike, usage: Usage): void {
-  usage.cost.input = (model.cost.input / 1_000_000) * usage.input
-  usage.cost.output = (model.cost.output / 1_000_000) * usage.output
-  usage.cost.cacheRead = (model.cost.cacheRead / 1_000_000) * usage.cacheRead
-  usage.cost.cacheWrite = (model.cost.cacheWrite / 1_000_000) * usage.cacheWrite
+  const inputTokens = usage.input + usage.cacheRead + usage.cacheWrite
+  let rates = model.cost
+  let matchedThreshold = -1
+  for (const tier of model.cost.tiers ?? []) {
+    if (inputTokens > tier.inputTokensAbove && tier.inputTokensAbove > matchedThreshold) {
+      rates = tier
+      matchedThreshold = tier.inputTokensAbove
+    }
+  }
+
+  const longWrite = usage.cacheWrite1h ?? 0
+  const shortWrite = usage.cacheWrite - longWrite
+  usage.cost.input = (rates.input / 1_000_000) * usage.input
+  usage.cost.output = (rates.output / 1_000_000) * usage.output
+  usage.cost.cacheRead = (rates.cacheRead / 1_000_000) * usage.cacheRead
+  usage.cost.cacheWrite = (rates.cacheWrite * shortWrite + rates.input * 2 * longWrite) / 1_000_000
   usage.cost.total =
     usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite
 }