Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

add child() to logger and thread request context through provider internals

Raine Virta6afc90ec13c8
diff --git a/src/log.ts b/src/log.ts
index 8da9a8e..0db75cd 100644
--- a/src/log.ts
+++ b/src/log.ts
@@ -112,13 +112,20 @@ export interface Logger {
info(msg: string, fields?: Record<string, unknown>): void
warn(msg: string, fields?: Record<string, unknown>): void
error(msg: string, fields?: Record<string, unknown>): void
+ child(bindings: Record<string, unknown>): Logger
}
-export function createLogger(service: string): Logger {
+export function createLogger(
+ service: string,
+ baseFields: Record<string, unknown> = {},
+): Logger {
+ const merge = (f?: Record<string, unknown>) =>
+ f ? { ...baseFields, ...f } : baseFields
return {
- debug: (msg, fields) => void write("debug", service, msg, fields),
- info: (msg, fields) => void write("info", service, msg, fields),
- warn: (msg, fields) => void write("warn", service, msg, fields),
- error: (msg, fields) => void write("error", service, msg, fields),
+ debug: (msg, fields) => void write("debug", service, msg, merge(fields)),
+ info: (msg, fields) => void write("info", service, msg, merge(fields)),
+ warn: (msg, fields) => void write("warn", service, msg, merge(fields)),
+ error: (msg, fields) => void write("error", service, msg, merge(fields)),
+ child: (bindings) => createLogger(service, { ...baseFields, ...bindings }),
}
}
diff --git a/src/providers/codex/client.ts b/src/providers/codex/client.ts
index b02d6b7..c98b248 100644
--- a/src/providers/codex/client.ts
+++ b/src/providers/codex/client.ts
@@ -1,15 +1,9 @@
import { CODEX_API_ENDPOINT, ORIGINATOR } from "./auth/constants.ts"
import { forceRefresh, getAuth } from "./auth/manager.ts"
-import { createLogger } from "../../log.ts"
+import type { Logger } from "../../log.ts"
+import type { RequestContext } from "../types.ts"
import type { ResponsesRequest } from "./translate/request.ts"
-const log = createLogger("codex.client")
-
-export interface CodexPostOptions {
- sessionId?: string
- signal?: AbortSignal
-}
-
export interface CodexResponse {
body: ReadableStream<Uint8Array>
status: number
@@ -18,16 +12,17 @@ export interface CodexResponse {
export async function postCodex(
body: ResponsesRequest,
- opts: CodexPostOptions = {},
+ ctx: RequestContext,
): Promise<CodexResponse> {
+ const log = ctx.childLogger("codex.client")
let auth = await getAuth()
- let resp = await doFetch(auth.access, auth.accountId, body, opts)
+ let resp = await doFetch(auth.access, auth.accountId, body, log, ctx.signal, ctx.sessionId)
if (resp.status === 401) {
log.warn("got 401, refreshing token", {})
try {
auth = await forceRefresh()
- resp = await doFetch(auth.access, auth.accountId, body, opts)
+ resp = await doFetch(auth.access, auth.accountId, body, log, ctx.signal, ctx.sessionId)
} catch (err) {
log.error("refresh after 401 failed", { err: String(err) })
}
@@ -59,7 +54,9 @@ async function doFetch(
accessToken: string,
accountId: string | undefined,
body: ResponsesRequest,
- opts: CodexPostOptions,
+ log: Logger,
+ signal?: AbortSignal,
+ sessionId?: string,
): Promise<Response> {
const headers = new Headers({
"Content-Type": "application/json",
@@ -69,10 +66,10 @@ async function doFetch(
"openai-beta": "responses=experimental",
})
if (accountId) headers.set("ChatGPT-Account-Id", accountId)
- if (opts.sessionId) {
- headers.set("session_id", opts.sessionId)
- headers.set("x-client-request-id", opts.sessionId)
- headers.set("x-codex-window-id", `${opts.sessionId}:0`)
+ if (sessionId) {
+ headers.set("session_id", sessionId)
+ headers.set("x-client-request-id", sessionId)
+ headers.set("x-codex-window-id", `${sessionId}:0`)
}
log.debug("posting to codex", {
@@ -80,14 +77,13 @@ async function doFetch(
model: body.model,
inputCount: body.input.length,
toolCount: body.tools?.length ?? 0,
- sessionId: opts.sessionId,
})
return fetch(CODEX_API_ENDPOINT, {
method: "POST",
headers,
body: JSON.stringify(body),
- signal: opts.signal,
+ signal,
})
}
diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.ts
index 1f43ed1..cf6f8d3 100644
--- a/src/providers/codex/index.ts
+++ b/src/providers/codex/index.ts
@@ -1,6 +1,5 @@
import type { AnthropicRequest } from "../../anthropic/schema.ts"
import type { Provider, RequestContext, CliHandlers } from "../types.ts"
-import { createLogger } from "../../log.ts"
import {
assertAllowedModel,
ModelNotAllowedError,
@@ -17,7 +16,6 @@ import { runDeviceLogin } from "./auth/device.ts"
import { persistInitialTokens } from "./auth/manager.ts"
import { loadAuth, authPath, clearAuth } from "./auth/token-store.ts"
-const log = createLogger("provider.codex")
const VERBOSE = !!process.env.CCP_LOG_VERBOSE
interface SessionCountSnapshot {
@@ -86,13 +84,14 @@ function jsonError(status: number, type: string, message: string): Response {
}
async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
+ const log = ctx.childLogger("provider.codex")
const resolvedModel = resolveModel(body.model)
const translated = translateRequest({ ...body, model: resolvedModel })
const tokens = countTranslatedTokens(translated)
const messageCount = body.messages?.length ?? 0
const toolCount = body.tools?.length ?? 0
const state = sessionState(ctx.sessionId)
- log.debug("count_tokens", { reqId: ctx.reqId, tokens })
+ log.debug("count_tokens", { tokens })
if (state) {
state.lastCount = {
reqId: ctx.reqId,
@@ -104,10 +103,7 @@ async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): P
}
if (VERBOSE) {
log.info("compaction telemetry", {
- reqId: ctx.reqId,
phase: "count_tokens",
- sessionId: ctx.sessionId,
- sessionSeq: ctx.sessionSeq,
model: body.model,
resolvedModel,
tokens,
@@ -127,6 +123,7 @@ async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): P
}
async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
+ const log = ctx.childLogger("provider.codex")
const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`
const wantStream = body.stream !== false
const messageCount = body.messages?.length ?? 0
@@ -135,17 +132,15 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
const state = sessionState(ctx.sessionId)
log.debug("anthropic request", {
- reqId: ctx.reqId,
model: body.model,
messageCount,
toolCount,
stream: wantStream,
- sessionId: ctx.sessionId,
requestedMaxTokens: body.max_tokens,
hasContextManagement: contextManagement !== undefined,
hasJsonSchemaFormat: body.output_config?.format?.type === "json_schema",
})
- if (VERBOSE) log.debug("anthropic request body", { reqId: ctx.reqId, body })
+ if (VERBOSE) log.debug("anthropic request body", { body })
const resolvedModel = resolveModel(body.model)
@@ -176,7 +171,6 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
}
}
log.debug("translated request", {
- reqId: ctx.reqId,
requestedModel: body.model,
resolvedModel,
inputItems: translated.input.length,
@@ -186,13 +180,10 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
hasContextManagement: contextManagement !== undefined,
promptCacheKey: translated.prompt_cache_key,
})
- if (VERBOSE) log.debug("translated request body", { reqId: ctx.reqId, body: translated })
+ if (VERBOSE) log.debug("translated request body", { body: translated })
if (VERBOSE) {
log.info("compaction telemetry", {
- reqId: ctx.reqId,
phase: "translated_request",
- sessionId: ctx.sessionId,
- sessionSeq: ctx.sessionSeq,
requestedModel: body.model,
resolvedModel,
messageCount,
@@ -215,10 +206,10 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
let upstream
try {
- upstream = await postCodex(translated, { sessionId: ctx.sessionId, signal: ctx.signal })
+ upstream = await postCodex(translated, ctx)
} catch (err) {
if (err instanceof CodexError) {
- log.warn("codex error", { reqId: ctx.reqId, status: err.status, detail: err.detail })
+ log.warn("codex error", { status: err.status, detail: err.detail })
if (err.status === 429) {
const headers: Record<string, string> = { "content-type": "application/json" }
if (err.meta?.retryAfter) headers["retry-after"] = err.meta.retryAfter
@@ -242,17 +233,13 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
const stream = translateStream(upstream.body, {
messageId,
model: body.model,
- reqId: ctx.reqId,
- sessionId: ctx.sessionId,
+ log: ctx.childLogger("codex.stream"),
onFinish: VERBOSE
? (finish) => {
const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined
log.info("compaction telemetry", {
- reqId: ctx.reqId,
phase: "upstream_finish",
mode: "stream",
- sessionId: ctx.sessionId,
- sessionSeq: ctx.sessionSeq,
requestedModel: body.model,
resolvedModel,
serverModel,
@@ -289,15 +276,12 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
}
try {
- const result = await accumulateResponse(upstream.body, { messageId, model: body.model })
+ const result = await accumulateResponse(upstream.body, { messageId, model: body.model, log: ctx.childLogger("codex.accumulate") })
if (VERBOSE) {
const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
log.info("compaction telemetry", {
- reqId: ctx.reqId,
phase: "upstream_finish",
mode: "non_stream",
- sessionId: ctx.sessionId,
- sessionSeq: ctx.sessionSeq,
requestedModel: body.model,
resolvedModel,
serverModel,
@@ -326,7 +310,6 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
} catch (err) {
if (err instanceof UpstreamStreamError) {
log.warn("upstream stream error (non-streaming)", {
- reqId: ctx.reqId,
kind: err.kind,
message: err.message,
})
diff --git a/src/providers/codex/translate/accumulate.ts b/src/providers/codex/translate/accumulate.ts
index 14fb047..712e606 100644
--- a/src/providers/codex/translate/accumulate.ts
+++ b/src/providers/codex/translate/accumulate.ts
@@ -1,5 +1,6 @@
import { mapUsageToAnthropic, reduceUpstream } from "./reducer.ts"
import type { CodexUsage } from "./reducer.ts"
+import type { Logger } from "../../../log.ts"
export { UpstreamStreamError } from "./reducer.ts"
@@ -35,7 +36,7 @@ export interface AccumulatedResponse {
*/
export async function accumulateResponse(
upstream: ReadableStream<Uint8Array>,
- opts: { messageId: string; model: string },
+ opts: { messageId: string; model: string; log: Logger },
): Promise<AccumulatedResponse> {
type Block =
| { kind: "text"; text: string }
@@ -47,7 +48,7 @@ export async function accumulateResponse(
let usage: ReturnType<typeof mapUsageToAnthropic> | undefined
let rawUsage: CodexUsage | undefined
- for await (const e of reduceUpstream(upstream)) {
+ for await (const e of reduceUpstream(upstream, opts.log)) {
switch (e.kind) {
case "text-start":
blocks.set(e.index, { kind: "text", text: "" })
diff --git a/src/providers/codex/translate/reducer.ts b/src/providers/codex/translate/reducer.ts
index 34ce0dd..9140e68 100644
--- a/src/providers/codex/translate/reducer.ts
+++ b/src/providers/codex/translate/reducer.ts
@@ -1,7 +1,6 @@
import { parseSseStream } from "../../../sse.ts"
-import { createLogger } from "../../../log.ts"
+import type { Logger } from "../../../log.ts"
-const log = createLogger("translate.reducer")
const VERBOSE = !!process.env.CCP_LOG_VERBOSE
export class UpstreamStreamError extends Error {
@@ -79,6 +78,7 @@ function sanitizeToolArgs(name: string, args: string): string {
*/
export async function* reduceUpstream(
upstream: ReadableStream<Uint8Array>,
+ log: Logger,
): AsyncGenerator<ReducerEvent> {
const blocksByOutputIndex = new Map<number, BlockState>()
const itemIdToOutputIndex = new Map<string, number>()
diff --git a/src/providers/codex/translate/stream.ts b/src/providers/codex/translate/stream.ts
index a9dd438..ba29961 100644
--- a/src/providers/codex/translate/stream.ts
+++ b/src/providers/codex/translate/stream.ts
@@ -1,9 +1,7 @@
import { encodeSseEvent } from "../../../sse.ts"
-import { createLogger } from "../../../log.ts"
+import type { Logger } from "../../../log.ts"
import { mapUsageToAnthropic, reduceUpstream, UpstreamStreamError } from "./reducer.ts"
-const log = createLogger("translate.stream")
-
/**
* Translate a Codex Responses SSE stream into Anthropic SSE events.
* Returns a ReadableStream<Uint8Array> ready to pipe to the client.
@@ -17,8 +15,7 @@ export function translateStream(
opts: {
messageId: string
model: string
- reqId: string
- sessionId?: string
+ log: Logger
onFinish?: (finish: { stopReason: "end_turn" | "tool_use" | "max_tokens"; usage?: Parameters<typeof mapUsageToAnthropic>[0] }) => void
},
): ReadableStream<Uint8Array> {
@@ -55,7 +52,7 @@ export function translateStream(
}
try {
- for await (const e of reduceUpstream(upstream)) {
+ for await (const e of reduceUpstream(upstream, opts.log)) {
switch (e.kind) {
case "text-start":
ensureMessageStart()
@@ -116,9 +113,7 @@ export function translateStream(
const activeToolNames = Array.from(activeTools.values(), (tool) => tool.name)
const activeToolCalls = Array.from(activeTools.values())
if (err instanceof UpstreamStreamError) {
- log.warn("upstream stream error", {
- reqId: opts.reqId,
- sessionId: opts.sessionId,
+ opts.log.warn("upstream stream error", {
kind: err.kind,
message: err.message,
activeToolNames,
@@ -133,9 +128,7 @@ export function translateStream(
},
})
} else {
- log.error("stream translation error", {
- reqId: opts.reqId,
- sessionId: opts.sessionId,
+ opts.log.error("stream translation error", {
err: String(err),
activeToolNames,
activeToolCalls,
diff --git a/src/providers/kimi/client.ts b/src/providers/kimi/client.ts
index 29dea5b..c141472 100644
--- a/src/providers/kimi/client.ts
+++ b/src/providers/kimi/client.ts
@@ -1,16 +1,10 @@
import { API_BASE_URL } from "./auth/constants.ts"
import { commonHeaders } from "./auth/headers.ts"
import { forceRefresh, getAuth, KimiAuthUnauthorizedError } from "./auth/manager.ts"
-import { createLogger } from "../../log.ts"
+import type { Logger } from "../../log.ts"
+import type { RequestContext } from "../types.ts"
import type { KimiChatRequest } from "./translate/request.ts"
-const log = createLogger("kimi.client")
-
-export interface KimiPostOptions {
- sessionId?: string
- signal?: AbortSignal
-}
-
export interface KimiResponse {
body: ReadableStream<Uint8Array>
status: number
@@ -31,16 +25,17 @@ export class KimiError extends Error {
export async function postKimi(
body: KimiChatRequest,
- opts: KimiPostOptions = {},
+ ctx: RequestContext,
): Promise<KimiResponse> {
+ const log = ctx.childLogger("kimi.client")
let auth = await getAuth()
- let resp = await doFetch(auth.access, body, opts)
+ let resp = await doFetch(auth.access, body, log, ctx.signal)
if (resp.status === 401) {
log.warn("got 401, refreshing token", {})
try {
auth = await forceRefresh()
- resp = await doFetch(auth.access, body, opts)
+ resp = await doFetch(auth.access, body, log, ctx.signal)
} catch (err) {
if (err instanceof KimiAuthUnauthorizedError) {
throw new KimiError(401, "Unauthorized", err.message)
@@ -69,7 +64,8 @@ export async function postKimi(
async function doFetch(
accessToken: string,
body: KimiChatRequest,
- opts: KimiPostOptions,
+ log: Logger,
+ signal?: AbortSignal,
): Promise<Response> {
const fp = await commonHeaders()
const headers = new Headers({
@@ -84,14 +80,13 @@ async function doFetch(
model: body.model,
messageCount: body.messages.length,
toolCount: body.tools?.length ?? 0,
- sessionId: opts.sessionId,
})
return fetch(`${API_BASE_URL}/chat/completions`, {
method: "POST",
headers,
body: JSON.stringify(body),
- signal: opts.signal,
+ signal,
})
}
diff --git a/src/providers/kimi/index.ts b/src/providers/kimi/index.ts
index d334f51..a164665 100644
--- a/src/providers/kimi/index.ts
+++ b/src/providers/kimi/index.ts
@@ -1,6 +1,5 @@
import type { Provider, CliHandlers, RequestContext } from "../types.ts"
import type { AnthropicRequest } from "../../anthropic/schema.ts"
-import { createLogger } from "../../log.ts"
import {
assertAllowedModel,
ModelNotAllowedError,
@@ -15,7 +14,6 @@ import { runDeviceLogin } from "./auth/login.ts"
import { persistInitialTokens } from "./auth/manager.ts"
import { loadAuth, clearAuth, authPath } from "./auth/token-store.ts"
-const log = createLogger("provider.kimi")
const VERBOSE = !!process.env.CCP_LOG_VERBOSE
function jsonError(status: number, type: string, message: string): Response {
@@ -26,31 +24,31 @@ function jsonError(status: number, type: string, message: string): Response {
}
async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
+ const log = ctx.childLogger("provider.kimi")
const resolvedModel = resolveModel(body.model)
const translated = translateRequest({ ...body, model: resolvedModel })
const tokens = countTranslatedTokens(translated)
- log.debug("count_tokens", { reqId: ctx.reqId, tokens })
+ log.debug("count_tokens", { tokens })
return new Response(JSON.stringify({ input_tokens: tokens }), {
headers: { "content-type": "application/json" },
})
}
async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
+ const log = ctx.childLogger("provider.kimi")
const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`
const wantStream = body.stream !== false
const messageCount = body.messages?.length ?? 0
const toolCount = body.tools?.length ?? 0
log.debug("anthropic request", {
- reqId: ctx.reqId,
model: body.model,
messageCount,
toolCount,
stream: wantStream,
- sessionId: ctx.sessionId,
requestedMaxTokens: body.max_tokens,
})
- if (VERBOSE) log.debug("anthropic request body", { reqId: ctx.reqId, body })
+ if (VERBOSE) log.debug("anthropic request body", { body })
const resolvedModel = resolveModel(body.model)
try {
@@ -73,7 +71,6 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
const localInputTokens = VERBOSE ? countTokens(body) : undefined
const translatedInputTokens = VERBOSE ? countTranslatedTokens(translated) : undefined
log.debug("translated request", {
- reqId: ctx.reqId,
requestedModel: body.model,
resolvedModel,
messageCount: translated.messages.length,
@@ -85,14 +82,14 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
thinking: translated.thinking?.type,
maxTokens: translated.max_tokens,
})
- if (VERBOSE) log.debug("translated request body", { reqId: ctx.reqId, body: translated })
+ if (VERBOSE) log.debug("translated request body", { body: translated })
let upstream
try {
- upstream = await postKimi(translated, { sessionId: ctx.sessionId, signal: ctx.signal })
+ upstream = await postKimi(translated, ctx)
} catch (err) {
if (err instanceof KimiError) {
- log.warn("kimi error", { reqId: ctx.reqId, status: err.status, detail: err.detail })
+ log.warn("kimi error", { status: err.status, detail: err.detail })
if (err.status === 429) {
const headers: Record<string, string> = { "content-type": "application/json" }
if (err.meta?.retryAfter) headers["retry-after"] = err.meta.retryAfter
@@ -115,8 +112,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
const stream = translateStream(upstream.body, {
messageId,
model: body.model,
- reqId: ctx.reqId,
- sessionId: ctx.sessionId,
+ log: ctx.childLogger("kimi.stream"),
})
return new Response(stream, {
status: 200,
@@ -129,14 +125,13 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
}
try {
- const result = await accumulateResponse(upstream.body, { messageId, model: body.model })
+ const result = await accumulateResponse(upstream.body, { messageId, model: body.model, log: ctx.childLogger("kimi.accumulate") })
return new Response(JSON.stringify(result.response), {
headers: { "content-type": "application/json" },
})
} catch (err) {
if (err instanceof UpstreamStreamError) {
log.warn("upstream stream error (non-streaming)", {
- reqId: ctx.reqId,
kind: err.kind,
message: err.message,
})
diff --git a/src/providers/kimi/translate/accumulate.ts b/src/providers/kimi/translate/accumulate.ts
index b9e8447..1d55a40 100644
--- a/src/providers/kimi/translate/accumulate.ts
+++ b/src/providers/kimi/translate/accumulate.ts
@@ -28,9 +28,11 @@ export interface AccumulatedResponse {
rawUsage?: KimiUsage
}
+import type { Logger } from "../../../log.ts"
+
export async function accumulateResponse(
upstream: ReadableStream<Uint8Array>,
- opts: { messageId: string; model: string },
+ opts: { messageId: string; model: string; log: Logger },
): Promise<AccumulatedResponse> {
type Block =
| { kind: "thinking"; text: string }
@@ -43,7 +45,7 @@ export async function accumulateResponse(
let usage: ReturnType<typeof mapUsageToAnthropic> | undefined
let rawUsage: KimiUsage | undefined
- for await (const e of reduceUpstream(upstream)) {
+ for await (const e of reduceUpstream(upstream, opts.log)) {
switch (e.kind) {
case "thinking-start":
blocks.set(e.index, { kind: "thinking", text: "" })
diff --git a/src/providers/kimi/translate/reducer.ts b/src/providers/kimi/translate/reducer.ts
index 23a7bf7..6279f7a 100644
--- a/src/providers/kimi/translate/reducer.ts
+++ b/src/providers/kimi/translate/reducer.ts
@@ -1,7 +1,6 @@
import { parseSseStream } from "../../../sse.ts"
-import { createLogger } from "../../../log.ts"
+import type { Logger } from "../../../log.ts"
-const log = createLogger("kimi.reducer")
const VERBOSE = !!process.env.CCP_LOG_VERBOSE
export class UpstreamStreamError extends Error {
@@ -70,6 +69,7 @@ interface ToolSlot {
*/
export async function* reduceUpstream(
upstream: ReadableStream<Uint8Array>,
+ log: Logger,
): AsyncGenerator<ReducerEvent> {
let nextBlockIndex = 0
let thinkingIndex: number | undefined
diff --git a/src/providers/kimi/translate/stream.ts b/src/providers/kimi/translate/stream.ts
index c0f792d..4206c11 100644
--- a/src/providers/kimi/translate/stream.ts
+++ b/src/providers/kimi/translate/stream.ts
@@ -1,10 +1,8 @@
import { encodeSseEvent } from "../../../sse.ts"
-import { createLogger } from "../../../log.ts"
+import type { Logger } from "../../../log.ts"
import { mapUsageToAnthropic, reduceUpstream, UpstreamStreamError } from "./reducer.ts"
import { makeThinkingSignature } from "./signature.ts"
-const log = createLogger("kimi.stream")
-
/**
* Translate a Kimi chat-completions SSE stream into Anthropic SSE events.
* HTTP status 200 is already committed before the first upstream event is
@@ -16,8 +14,7 @@ export function translateStream(
opts: {
messageId: string
model: string
- reqId: string
- sessionId?: string
+ log: Logger
onFinish?: (finish: {
stopReason: "end_turn" | "tool_use" | "max_tokens"
usage?: Parameters<typeof mapUsageToAnthropic>[0]
@@ -57,7 +54,7 @@ export function translateStream(
}
try {
- for await (const e of reduceUpstream(upstream)) {
+ for await (const e of reduceUpstream(upstream, opts.log)) {
switch (e.kind) {
case "thinking-start":
ensureMessageStart()
@@ -148,9 +145,7 @@ export function translateStream(
const activeToolNames = Array.from(activeTools.values(), (t) => t.name)
const activeToolCalls = Array.from(activeTools.values())
if (err instanceof UpstreamStreamError) {
- log.warn("upstream stream error", {
- reqId: opts.reqId,
- sessionId: opts.sessionId,
+ opts.log.warn("upstream stream error", {
kind: err.kind,
message: err.message,
activeToolNames,
@@ -165,9 +160,7 @@ export function translateStream(
},
})
} else {
- log.error("stream translation error", {
- reqId: opts.reqId,
- sessionId: opts.sessionId,
+ opts.log.error("stream translation error", {
err: String(err),
activeToolNames,
activeToolCalls,
diff --git a/src/providers/types.ts b/src/providers/types.ts
index bc9733e..d3bb3d7 100644
--- a/src/providers/types.ts
+++ b/src/providers/types.ts
@@ -1,10 +1,13 @@
import type { AnthropicRequest } from "../anthropic/schema.ts"
+import type { Logger } from "../log.ts"
+
export interface RequestContext {
reqId: string
sessionId?: string
sessionSeq?: number
signal: AbortSignal
+ childLogger(service: string): Logger
}
export interface CliHandlers {
diff --git a/src/server.ts b/src/server.ts
index 6f2da8c..2afe17f 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,9 +1,10 @@
import { createLogger, logDir } from "./log.ts"
+
import type { AnthropicRequest } from "./anthropic/schema.ts"
import type { Provider, RequestContext } from "./providers/types.ts"
import { allSupportedModels, providerForModel } from "./providers/registry.ts"
-const log = createLogger("server")
+const rootLog = createLogger("server")
export interface ServeOptions {
port: number
@@ -27,7 +28,7 @@ export function startServer(opts: ServeOptions): { stop: () => void; port: numbe
const url = new URL(req.url)
const start = Date.now()
const reqId = crypto.randomUUID()
- log.info("request", {
+ rootLog.info("request", {
reqId,
method: req.method,
path: url.pathname,
@@ -35,15 +36,15 @@ export function startServer(opts: ServeOptions): { stop: () => void; port: numbe
})
try {
const resp = await route(req, url, reqId)
- log.info("response", { reqId, status: resp.status, ms: Date.now() - start })
+ rootLog.info("response", { reqId, status: resp.status, ms: Date.now() - start })
return resp
} catch (err) {
- log.error("handler error", { reqId, err: String(err), stack: (err as Error)?.stack })
+ rootLog.error("handler error", { reqId, err: String(err), stack: (err as Error)?.stack })
return jsonError(500, "internal_error", String(err))
}
},
})
- log.info("server listening", { port: server.port, logDir: logDir() })
+ rootLog.info("server listening", { port: server.port, logDir: logDir() })
return {
port: Number(server.port),
stop: () => server.stop(),
@@ -62,8 +63,8 @@ async function route(req: Request, url: URL, reqId: string): Promise<Response> {
if (body instanceof Response) return body
const provider = routeProvider(body, reqId)
if (provider instanceof Response) return provider
- const ctx = buildCtx(req, reqId)
- log.info("dispatch", { reqId, provider: provider.name, model: body.model })
+ const ctx = buildCtx(req, reqId, provider.name)
+ ctx.childLogger("server").info("dispatch", { model: body.model })
return provider.handleCountTokens(body, ctx)
}
@@ -72,21 +73,24 @@ async function route(req: Request, url: URL, reqId: string): Promise<Response> {
if (body instanceof Response) return body
const provider = routeProvider(body, reqId)
if (provider instanceof Response) return provider
- const ctx = buildCtx(req, reqId)
- log.info("dispatch", { reqId, provider: provider.name, model: body.model })
+ const ctx = buildCtx(req, reqId, provider.name)
+ ctx.childLogger("server").info("dispatch", { model: body.model })
return provider.handleMessages(body, ctx)
}
return jsonError(404, "not_found", `No route for ${req.method} ${url.pathname}`)
}
-function buildCtx(req: Request, reqId: string): RequestContext {
+function buildCtx(req: Request, reqId: string, providerName: string): RequestContext {
const sessionId = req.headers.get("x-claude-code-session-id") || undefined
+ const sessionSeq = nextSessionSeq(sessionId)
+ const bindings = { reqId, sessionId, sessionSeq, provider: providerName }
return {
reqId,
sessionId,
- sessionSeq: nextSessionSeq(sessionId),
+ sessionSeq,
signal: req.signal,
+ childLogger: (service) => createLogger(service, bindings),
}
}
@@ -100,7 +104,7 @@ function routeProvider(body: AnthropicRequest, reqId: string): Provider | Respon
}
const provider = providerForModel(body.model)
if (!provider) {
- log.warn("unknown model", { reqId, model: body.model })
+ rootLog.warn("unknown model", { reqId, model: body.model })
return jsonError(
400,
"invalid_request_error",