UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

144 lines (141 loc) • 11.3 kB
import { createHash } from "node:crypto"; import type { ProviderAdapter, IncomingMeta } from "./base"; import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig } from "../types"; import { namespacedToolName } from "../types"; import { createOpenAIChatAdapter } from "./openai-chat"; import { M365_COPILOT_BASE_URL } from "../providers/m365-copilot-models"; import { m365CopilotClaims } from "../oauth/m365-copilot"; import { SendBudgetExhaustedError, providerErrorDestinationLabel } from "../lib/upstream-retry"; import { estimateTokens } from "../lib/token-estimate"; import { formatMessages, formatToolResponse, parseToolCalls, isProseDocument, fabricatedToolResponseAt, truncateAtFabricatedToolResponse, type Message, type ToolDef, type ToolChoice } from "./m365-copilot/tools"; import { defaultFramingForModel } from "./m365-copilot/fenced"; import { createM365Conversation, runM365CopilotTurn, m365RequestSocketRoute, M365CopilotTurnError, type M365Conversation, type M365TurnOptions } from "./m365-copilot/transport"; import { m365ImageUrls, uploadM365Images, MAX_IMAGES } from "./m365-copilot/images"; interface ConversationState { conversation: M365Conversation; sent: number; prefix: string; sentImages: number; imagePrefix: string; accessed: number; tail: Promise<void>; pendingNote?: string } const conversations = new Map<string, ConversationState>(); function digest(value: string): string { return createHash("sha256").update(value).digest("hex"); } export function clearM365CopilotConversations(): void { conversations.clear(); } export function createM365CopilotAdapter(provider: OcxProviderConfig, deps: { turn?: (options: M365TurnOptions) => Promise<string> } = {}): ProviderAdapter { const formatter = createOpenAIChatAdapter({ ...provider, adapter: "openai-chat" }); return { name: "m365-copilot", reportsPhysicalSends: true, buildRequest: (parsed, incoming) => formatter.buildRequest(parsed, incoming), parseStream: (response, budget, tier) => formatter.parseStream(response, budget, tier), parseResponse: (response, budget, tier) => formatter.parseResponse!(response, budget, tier), async runTurn(parsed: OcxParsedRequest, incoming: IncomingMeta, emit: (event: AdapterEvent) => void) { if (provider.baseUrl.replace(/\/$/, "") !== M365_COPILOT_BASE_URL) throw new Error("Microsoft 365 Copilot requires its fixed Microsoft endpoint"); const token = provider.apiKey; if (!token) { emit({ type: "error", message: "Sign in to Microsoft 365 Copilot first", status: 401, retryable: false }); return; } const claims = m365CopilotClaims(token); const request = await formatter.buildRequest(parsed, incoming); let messages: Message[]; let tools: ToolDef[] | undefined; let toolChoice: ToolChoice; try { const body = JSON.parse(request.body); messages = body.messages; tools = body.tools; toolChoice = body.tool_choice; } finally { request.releaseBodyObservation?.(); } request.body = ""; if (!Array.isArray(messages)) throw new Error("Microsoft 365 Copilot request has no messages"); const first = messages.find(message => message.role === "user"); const { clientPrincipalId, clientThreadId } = parsed._reasoningReplayScope ?? {}; const key = clientPrincipalId && clientThreadId ? digest(JSON.stringify([claims.oid, claims.tid, parsed.modelId, clientPrincipalId, clientThreadId, first?.content, tools?.map(tool => tool.function.name).sort()])) : undefined; for (const [id, state] of conversations) if (Date.now() - state.accessed > 30 * 60_000) conversations.delete(id); let state = key === undefined ? undefined : conversations.get(key); let rebuilt = false; if (!state) { state = { conversation: createM365Conversation(), sent: 0, prefix: "", sentImages: 0, imagePrefix: "", accessed: Date.now(), tail: Promise.resolve() }; if (key !== undefined) { if (conversations.size >= 64) conversations.delete(conversations.keys().next().value!); conversations.set(key, state); } } const previous = state.tail; let release!: () => void; state.tail = new Promise(resolve => { release = resolve; }); await previous; let heartbeat: ReturnType<typeof setInterval> | undefined; try { incoming.abortSignal?.throwIfAborted(); const route = m365RequestSocketRoute({ ...provider, providerFetch: incoming.providerFetch }); const imageUrls = m365ImageUrls(parsed.context.messages); if (messages.length <= state.sent || state.prefix !== digest(JSON.stringify(messages.slice(0, state.sent))) || state.sentImages > imageUrls.length || state.sentImages > 0 && state.imagePrefix !== digest(JSON.stringify(imageUrls.slice(0, state.sentImages)))) { state.conversation = createM365Conversation(); state.sent = 0; state.sentImages = 0; state.imagePrefix = ""; state.pendingNote = undefined; rebuilt = true; } const fresh = messages.slice(state.sent).filter(message => message.role !== "assistant"); let text = state.sent === 0 ? formatMessages(messages, tools, toolChoice, undefined, defaultFramingForModel(parsed.modelId)) : fresh.map(message => message.role === "tool" ? formatToolResponse(message, messages) : formatMessages([message])).join("\n\n"); if (state.pendingNote) { text = state.pendingNote + "\n" + text; state.pendingNote = undefined; } if (Buffer.byteLength(text) > 16 * 1024 * 1024) throw new M365CopilotTurnError("Microsoft 365 Copilot request exceeded its size limit", 413); const toolMode = !!tools?.length && toolChoice !== "none"; let emittedToolCalls = 0; let thinkingText = ""; heartbeat = setInterval(() => emit({ type: "heartbeat" }), 5_000); // A rebuilt conversation replays its whole history in one turn; ChatHub caps a turn at four images, so keep only // the newest four historical images and mark the skipped ones as sent so a retry never re-uploads them. if (rebuilt && imageUrls.length > MAX_IMAGES && messages.some(message => message.role === "assistant")) state.sentImages = imageUrls.length - MAX_IMAGES; const images = await uploadM365Images(imageUrls.slice(state.sentImages), token, parsed.modelId, state.conversation.conversationId, provider, incoming.abortSignal, incoming.translatorBudget, () => { incoming.beforeCredentialSend?.(); incoming.beforePhysicalSend?.(); }); const answer = await (deps.turn ?? runM365CopilotTurn)({ token, model: parsed.modelId, text, images, conversation: state.conversation, signal: incoming.abortSignal, budget: incoming.translatorBudget, route, beforeConnect: incoming.beforeCredentialSend, onText: delta => { if (!toolMode) emit({ type: "text_delta", text: delta }); }, onThinking: thinking => { if (!thinking) return; thinkingText += thinking; emit({ type: "thinking_delta", thinking }); }, beforeSend: () => { incoming.beforeCredentialSend?.(); incoming.beforePhysicalSend?.(); const admission = incoming.sendBudget?.reserveDispatch({ sendClass: "initial", targetKey: "m365-copilot|" + parsed.modelId + "|" + digest(claims.oid + claims.tid) }); if (admission && !admission.allowed) throw new SendBudgetExhaustedError(providerErrorDestinationLabel("m365-copilot")); if (admission) { // A refused (or throwing) final admission sends no chat frame, so its reservation must be refunded. let used = false; try { used = admission.permit.use(); } finally { if (!used) admission.permit.release(); } if (!used) throw new SendBudgetExhaustedError(providerErrorDestinationLabel("m365-copilot")); } incoming.onPhysicalSend?.({ ordinal: 1 }); }, }); state.sent = messages.length; state.prefix = digest(JSON.stringify(messages)); state.accessed = Date.now(); state.sentImages = imageUrls.length; state.imagePrefix = digest(JSON.stringify(imageUrls)); if (toolMode) { if (fabricatedToolResponseAt(answer, tools) >= 0) state.pendingNote = "Only tool calls returned to the client were executed. Any tool output you wrote yourself did not happen; the following is the real client output."; const cleaned = truncateAtFabricatedToolResponse(answer, tools); const result = parseToolCalls(cleaned, tools); if (isProseDocument(result, cleaned, tools)) emit({ type: "text_delta", text: cleaned }); else { // Validate every call before emitting anything: a malformed or undeclared call must not leave the client with partial output. const calls = result.toolCalls.map(call => { if (!tools!.some(tool => tool.function.name === call.function.name)) throw new M365CopilotTurnError("Microsoft 365 Copilot returned an undeclared tool"); let args: Record<string, unknown> | undefined; try { const value = JSON.parse(call.function.arguments); if (value && typeof value === "object") args = value; } catch { throw new M365CopilotTurnError("Microsoft 365 Copilot returned invalid tool arguments"); } const alias = request.convertedRoutedNamespaceToolAliases?.get(call.function.name); const name = alias ? namespacedToolName(alias.namespace, alias.name) : call.function.name; const original = parsed.context.tools?.find(tool => namespacedToolName(tool.namespace, tool.name) === name); return { call, name, freeform: original?.freeform === true && typeof args?.input === "string" ? args.input : undefined }; }); if (result.textContent) emit({ type: "text_delta", text: result.textContent }); for (const { call, name, freeform } of calls) { emit({ type: "tool_call_start", id: call.id, name }); emit({ type: "tool_call_delta", arguments: freeform ?? call.function.arguments }); emit({ type: "tool_call_end" }); emittedToolCalls++; } } } // ChatHub reports no token counts; estimate from the full prompt the model sees and its reply. // shortcut: image tokens use a fixed allowance, replace when Microsoft exposes image usage. const inputTokens = estimateTokens(JSON.stringify([messages, tools ?? []], (key, value) => key === "image_url" ? "[image]" : value), parsed.modelId) + imageUrls.length * 256; const outputTokens = estimateTokens(answer + thinkingText, parsed.modelId); emit({ type: "done", stopReason: emittedToolCalls ? "tool_use" : "stop", endTurn: emittedToolCalls === 0, usage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens, estimated: true } }); } catch (error) { if (key !== undefined && conversations.get(key) === state) conversations.delete(key); if (error instanceof M365CopilotTurnError) emit({ type: "error", message: error.message, status: error.status, retryable: false }); else throw error; } finally { if (heartbeat) clearInterval(heartbeat); release(); } }, }; }