| ... | ... | @@ -1,1857 +0,0 @@ |
| 1 | | /** |
| 2 | | * ClaudeCodeAdapterLive - Scoped live implementation for the Claude Code provider adapter. |
| 3 | | * |
| 4 | | * Wraps `@anthropic-ai/claude-agent-sdk` query sessions behind the generic |
| 5 | | * provider adapter contract and emits canonical runtime events. |
| 6 | | * |
| 7 | | * @module ClaudeCodeAdapterLive |
| 8 | | */ |
| 9 | | import { |
| 10 | | type CanUseTool, |
| 11 | | query, |
| 12 | | type Options as ClaudeQueryOptions, |
| 13 | | type PermissionMode, |
| 14 | | type PermissionResult, |
| 15 | | type PermissionUpdate, |
| 16 | | type SDKMessage, |
| 17 | | type SDKResultMessage, |
| 18 | | type SDKUserMessage, |
| 19 | | } from "@anthropic-ai/claude-agent-sdk"; |
| 20 | | import { |
| 21 | | ApprovalRequestId, |
| 22 | | type CanonicalItemType, |
| 23 | | type CanonicalRequestType, |
| 24 | | EventId, |
| 25 | | type ProviderApprovalDecision, |
| 26 | | ProviderItemId, |
| 27 | | type ProviderRuntimeEvent, |
| 28 | | type ProviderRuntimeTurnStatus, |
| 29 | | type ProviderSendTurnInput, |
| 30 | | type ProviderSession, |
| 31 | | RuntimeItemId, |
| 32 | | RuntimeRequestId, |
| 33 | | RuntimeTaskId, |
| 34 | | ThreadId, |
| 35 | | TurnId, |
| 36 | | } from "@t3tools/contracts"; |
| 37 | | import { Cause, DateTime, Deferred, Effect, Layer, Queue, Random, Ref, Stream } from "effect"; |
| 38 | | |
| 39 | | import { |
| 40 | | ProviderAdapterProcessError, |
| 41 | | ProviderAdapterRequestError, |
| 42 | | ProviderAdapterSessionClosedError, |
| 43 | | ProviderAdapterSessionNotFoundError, |
| 44 | | ProviderAdapterValidationError, |
| 45 | | type ProviderAdapterError, |
| 46 | | } from "../Errors.ts"; |
| 47 | | import { ClaudeCodeAdapter, type ClaudeCodeAdapterShape } from "../Services/ClaudeCodeAdapter.ts"; |
| 48 | | import { type EventNdjsonLogger, makeEventNdjsonLogger } from "./EventNdjsonLogger.ts"; |
| 49 | | |
| 50 | | const PROVIDER = "claudeCode" as const; |
| 51 | | |
| 52 | | type PromptQueueItem = |
| 53 | | | { |
| 54 | | readonly type: "message"; |
| 55 | | readonly message: SDKUserMessage; |
| 56 | | } |
| 57 | | | { |
| 58 | | readonly type: "terminate"; |
| 59 | | }; |
| 60 | | |
| 61 | | interface ClaudeResumeState { |
| 62 | | readonly threadId?: ThreadId; |
| 63 | | readonly resume?: string; |
| 64 | | readonly resumeSessionAt?: string; |
| 65 | | readonly turnCount?: number; |
| 66 | | } |
| 67 | | |
| 68 | | interface ClaudeTurnState { |
| 69 | | readonly turnId: TurnId; |
| 70 | | readonly assistantItemId: string; |
| 71 | | readonly startedAt: string; |
| 72 | | readonly items: Array<unknown>; |
| 73 | | readonly messageCompleted: boolean; |
| 74 | | readonly emittedTextDelta: boolean; |
| 75 | | readonly fallbackAssistantText: string; |
| 76 | | } |
| 77 | | |
| 78 | | interface PendingApproval { |
| 79 | | readonly requestType: CanonicalRequestType; |
| 80 | | readonly detail?: string; |
| 81 | | readonly suggestions?: ReadonlyArray<PermissionUpdate>; |
| 82 | | readonly decision: Deferred.Deferred<ProviderApprovalDecision>; |
| 83 | | } |
| 84 | | |
| 85 | | interface ToolInFlight { |
| 86 | | readonly itemId: string; |
| 87 | | readonly itemType: CanonicalItemType; |
| 88 | | readonly toolName: string; |
| 89 | | readonly title: string; |
| 90 | | readonly detail?: string; |
| 91 | | } |
| 92 | | |
| 93 | | interface ClaudeSessionContext { |
| 94 | | session: ProviderSession; |
| 95 | | readonly promptQueue: Queue.Queue<PromptQueueItem>; |
| 96 | | readonly query: ClaudeQueryRuntime; |
| 97 | | readonly startedAt: string; |
| 98 | | resumeSessionId: string | undefined; |
| 99 | | readonly pendingApprovals: Map<ApprovalRequestId, PendingApproval>; |
| 100 | | readonly turns: Array<{ |
| 101 | | id: TurnId; |
| 102 | | items: Array<unknown>; |
| 103 | | }>; |
| 104 | | readonly inFlightTools: Map<number, ToolInFlight>; |
| 105 | | turnState: ClaudeTurnState | undefined; |
| 106 | | lastAssistantUuid: string | undefined; |
| 107 | | lastThreadStartedId: string | undefined; |
| 108 | | stopped: boolean; |
| 109 | | } |
| 110 | | |
| 111 | | interface ClaudeQueryRuntime extends AsyncIterable<SDKMessage> { |
| 112 | | readonly interrupt: () => Promise<void>; |
| 113 | | readonly setModel: (model?: string) => Promise<void>; |
| 114 | | readonly setPermissionMode: (mode: PermissionMode) => Promise<void>; |
| 115 | | readonly setMaxThinkingTokens: (maxThinkingTokens: number | null) => Promise<void>; |
| 116 | | readonly close: () => void; |
| 117 | | } |
| 118 | | |
| 119 | | export interface ClaudeCodeAdapterLiveOptions { |
| 120 | | readonly createQuery?: (input: { |
| 121 | | readonly prompt: AsyncIterable<SDKUserMessage>; |
| 122 | | readonly options: ClaudeQueryOptions; |
| 123 | | }) => ClaudeQueryRuntime; |
| 124 | | readonly nativeEventLogPath?: string; |
| 125 | | readonly nativeEventLogger?: EventNdjsonLogger; |
| 126 | | } |
| 127 | | |
| 128 | | function isUuid(value: string): boolean { |
| 129 | | return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value); |
| 130 | | } |
| 131 | | |
| 132 | | function isSyntheticClaudeThreadId(value: string): boolean { |
| 133 | | return value.startsWith("claude-thread-"); |
| 134 | | } |
| 135 | | |
| 136 | | function toMessage(cause: unknown, fallback: string): string { |
| 137 | | if (cause instanceof Error && cause.message.length > 0) { |
| 138 | | return cause.message; |
| 139 | | } |
| 140 | | return fallback; |
| 141 | | } |
| 142 | | |
| 143 | | function asRuntimeItemId(value: string): RuntimeItemId { |
| 144 | | return RuntimeItemId.makeUnsafe(value); |
| 145 | | } |
| 146 | | |
| 147 | | function asCanonicalTurnId(value: TurnId): TurnId { |
| 148 | | return value; |
| 149 | | } |
| 150 | | |
| 151 | | function asRuntimeRequestId(value: ApprovalRequestId): RuntimeRequestId { |
| 152 | | return RuntimeRequestId.makeUnsafe(value); |
| 153 | | } |
| 154 | | |
| 155 | | function toPermissionMode(value: unknown): PermissionMode | undefined { |
| 156 | | switch (value) { |
| 157 | | case "default": |
| 158 | | case "acceptEdits": |
| 159 | | case "bypassPermissions": |
| 160 | | case "plan": |
| 161 | | case "dontAsk": |
| 162 | | return value; |
| 163 | | default: |
| 164 | | return undefined; |
| 165 | | } |
| 166 | | } |
| 167 | | |
| 168 | | function readClaudeResumeState(resumeCursor: unknown): ClaudeResumeState | undefined { |
| 169 | | if (!resumeCursor || typeof resumeCursor !== "object") { |
| 170 | | return undefined; |
| 171 | | } |
| 172 | | const cursor = resumeCursor as { |
| 173 | | threadId?: unknown; |
| 174 | | resume?: unknown; |
| 175 | | sessionId?: unknown; |
| 176 | | resumeSessionAt?: unknown; |
| 177 | | turnCount?: unknown; |
| 178 | | }; |
| 179 | | |
| 180 | | const threadIdCandidate = typeof cursor.threadId === "string" ? cursor.threadId : undefined; |
| 181 | | const threadId = |
| 182 | | threadIdCandidate && !isSyntheticClaudeThreadId(threadIdCandidate) |
| 183 | | ? ThreadId.makeUnsafe(threadIdCandidate) |
| 184 | | : undefined; |
| 185 | | const resumeCandidate = |
| 186 | | typeof cursor.resume === "string" |
| 187 | | ? cursor.resume |
| 188 | | : typeof cursor.sessionId === "string" |
| 189 | | ? cursor.sessionId |
| 190 | | : undefined; |
| 191 | | const resume = resumeCandidate && isUuid(resumeCandidate) ? resumeCandidate : undefined; |
| 192 | | const resumeSessionAt = |
| 193 | | typeof cursor.resumeSessionAt === "string" ? cursor.resumeSessionAt : undefined; |
| 194 | | const turnCountValue = typeof cursor.turnCount === "number" ? cursor.turnCount : undefined; |
| 195 | | |
| 196 | | return { |
| 197 | | ...(threadId ? { threadId } : {}), |
| 198 | | ...(resume ? { resume } : {}), |
| 199 | | ...(resumeSessionAt ? { resumeSessionAt } : {}), |
| 200 | | ...(turnCountValue !== undefined && Number.isInteger(turnCountValue) && turnCountValue >= 0 |
| 201 | | ? { turnCount: turnCountValue } |
| 202 | | : {}), |
| 203 | | }; |
| 204 | | } |
| 205 | | |
| 206 | | function classifyToolItemType(toolName: string): CanonicalItemType { |
| 207 | | const normalized = toolName.toLowerCase(); |
| 208 | | if ( |
| 209 | | normalized.includes("bash") || |
| 210 | | normalized.includes("command") || |
| 211 | | normalized.includes("shell") || |
| 212 | | normalized.includes("terminal") |
| 213 | | ) { |
| 214 | | return "command_execution"; |
| 215 | | } |
| 216 | | if ( |
| 217 | | normalized.includes("edit") || |
| 218 | | normalized.includes("write") || |
| 219 | | normalized.includes("file") || |
| 220 | | normalized.includes("patch") || |
| 221 | | normalized.includes("replace") || |
| 222 | | normalized.includes("create") || |
| 223 | | normalized.includes("delete") |
| 224 | | ) { |
| 225 | | return "file_change"; |
| 226 | | } |
| 227 | | if (normalized.includes("mcp")) { |
| 228 | | return "mcp_tool_call"; |
| 229 | | } |
| 230 | | return "dynamic_tool_call"; |
| 231 | | } |
| 232 | | |
| 233 | | function classifyRequestType(toolName: string): CanonicalRequestType { |
| 234 | | const normalized = toolName.toLowerCase(); |
| 235 | | if (normalized === "read" || normalized.includes("read file") || normalized.includes("view")) { |
| 236 | | return "file_read_approval"; |
| 237 | | } |
| 238 | | return classifyToolItemType(toolName) === "command_execution" |
| 239 | | ? "command_execution_approval" |
| 240 | | : "file_change_approval"; |
| 241 | | } |
| 242 | | |
| 243 | | function summarizeToolRequest(toolName: string, input: Record<string, unknown>): string { |
| 244 | | const commandValue = input.command ?? input.cmd; |
| 245 | | const command = typeof commandValue === "string" ? commandValue : undefined; |
| 246 | | if (command && command.trim().length > 0) { |
| 247 | | return `${toolName}: ${command.trim().slice(0, 400)}`; |
| 248 | | } |
| 249 | | |
| 250 | | const serialized = JSON.stringify(input); |
| 251 | | if (serialized.length <= 400) { |
| 252 | | return `${toolName}: ${serialized}`; |
| 253 | | } |
| 254 | | return `${toolName}: ${serialized.slice(0, 397)}...`; |
| 255 | | } |
| 256 | | |
| 257 | | function titleForTool(itemType: CanonicalItemType): string { |
| 258 | | switch (itemType) { |
| 259 | | case "command_execution": |
| 260 | | return "Command run"; |
| 261 | | case "file_change": |
| 262 | | return "File change"; |
| 263 | | case "mcp_tool_call": |
| 264 | | return "MCP tool call"; |
| 265 | | case "dynamic_tool_call": |
| 266 | | return "Tool call"; |
| 267 | | default: |
| 268 | | return "Item"; |
| 269 | | } |
| 270 | | } |
| 271 | | |
| 272 | | function buildUserMessage(input: ProviderSendTurnInput): SDKUserMessage { |
| 273 | | const fragments: string[] = []; |
| 274 | | |
| 275 | | if (input.input && input.input.trim().length > 0) { |
| 276 | | fragments.push(input.input.trim()); |
| 277 | | } |
| 278 | | |
| 279 | | for (const attachment of input.attachments ?? []) { |
| 280 | | if (attachment.type === "image") { |
| 281 | | fragments.push( |
| 282 | | `Attached image: ${attachment.name} (${attachment.mimeType}, ${attachment.sizeBytes} bytes).`, |
| 283 | | ); |
| 284 | | } |
| 285 | | } |
| 286 | | |
| 287 | | const text = fragments.join("\n\n"); |
| 288 | | |
| 289 | | return { |
| 290 | | type: "user", |
| 291 | | session_id: "", |
| 292 | | parent_tool_use_id: null, |
| 293 | | message: { |
| 294 | | role: "user", |
| 295 | | content: [{ type: "text", text }], |
| 296 | | }, |
| 297 | | } as SDKUserMessage; |
| 298 | | } |
| 299 | | |
| 300 | | function turnStatusFromResult(result: SDKResultMessage): ProviderRuntimeTurnStatus { |
| 301 | | if (result.subtype === "success") { |
| 302 | | return "completed"; |
| 303 | | } |
| 304 | | |
| 305 | | const errors = result.errors.join(" ").toLowerCase(); |
| 306 | | if (errors.includes("interrupt")) { |
| 307 | | return "interrupted"; |
| 308 | | } |
| 309 | | if (errors.includes("cancel")) { |
| 310 | | return "cancelled"; |
| 311 | | } |
| 312 | | return "failed"; |
| 313 | | } |
| 314 | | |
| 315 | | function streamKindFromDeltaType(deltaType: string): "assistant_text" | "reasoning_text" { |
| 316 | | return deltaType.includes("thinking") ? "reasoning_text" : "assistant_text"; |
| 317 | | } |
| 318 | | |
| 319 | | function providerThreadRef( |
| 320 | | context: ClaudeSessionContext, |
| 321 | | ): { readonly providerThreadId: string } | {} { |
| 322 | | return context.resumeSessionId ? { providerThreadId: context.resumeSessionId } : {}; |
| 323 | | } |
| 324 | | |
| 325 | | function extractAssistantText(message: SDKMessage): string { |
| 326 | | if (message.type !== "assistant") { |
| 327 | | return ""; |
| 328 | | } |
| 329 | | |
| 330 | | const content = (message.message as { content?: unknown } | undefined)?.content; |
| 331 | | if (!Array.isArray(content)) { |
| 332 | | return ""; |
| 333 | | } |
| 334 | | |
| 335 | | const fragments: string[] = []; |
| 336 | | for (const block of content) { |
| 337 | | if (!block || typeof block !== "object") { |
| 338 | | continue; |
| 339 | | } |
| 340 | | const candidate = block as { type?: unknown; text?: unknown }; |
| 341 | | if ( |
| 342 | | candidate.type === "text" && |
| 343 | | typeof candidate.text === "string" && |
| 344 | | candidate.text.length > 0 |
| 345 | | ) { |
| 346 | | fragments.push(candidate.text); |
| 347 | | } |
| 348 | | } |
| 349 | | |
| 350 | | return fragments.join(""); |
| 351 | | } |
| 352 | | |
| 353 | | function toSessionError( |
| 354 | | threadId: ThreadId, |
| 355 | | cause: unknown, |
| 356 | | ): ProviderAdapterSessionNotFoundError | ProviderAdapterSessionClosedError | undefined { |
| 357 | | const normalized = toMessage(cause, "").toLowerCase(); |
| 358 | | if (normalized.includes("unknown session") || normalized.includes("not found")) { |
| 359 | | return new ProviderAdapterSessionNotFoundError({ |
| 360 | | provider: PROVIDER, |
| 361 | | threadId, |
| 362 | | cause, |
| 363 | | }); |
| 364 | | } |
| 365 | | if (normalized.includes("closed")) { |
| 366 | | return new ProviderAdapterSessionClosedError({ |
| 367 | | provider: PROVIDER, |
| 368 | | threadId, |
| 369 | | cause, |
| 370 | | }); |
| 371 | | } |
| 372 | | return undefined; |
| 373 | | } |
| 374 | | |
| 375 | | function toRequestError( |
| 376 | | threadId: ThreadId, |
| 377 | | method: string, |
| 378 | | cause: unknown, |
| 379 | | ): ProviderAdapterError { |
| 380 | | const sessionError = toSessionError(threadId, cause); |
| 381 | | if (sessionError) { |
| 382 | | return sessionError; |
| 383 | | } |
| 384 | | return new ProviderAdapterRequestError({ |
| 385 | | provider: PROVIDER, |
| 386 | | method, |
| 387 | | detail: toMessage(cause, `${method} failed`), |
| 388 | | cause, |
| 389 | | }); |
| 390 | | } |
| 391 | | |
| 392 | | function sdkMessageType(value: unknown): string | undefined { |
| 393 | | if (!value || typeof value !== "object") { |
| 394 | | return undefined; |
| 395 | | } |
| 396 | | const record = value as { type?: unknown }; |
| 397 | | return typeof record.type === "string" ? record.type : undefined; |
| 398 | | } |
| 399 | | |
| 400 | | function sdkMessageSubtype(value: unknown): string | undefined { |
| 401 | | if (!value || typeof value !== "object") { |
| 402 | | return undefined; |
| 403 | | } |
| 404 | | const record = value as { subtype?: unknown }; |
| 405 | | return typeof record.subtype === "string" ? record.subtype : undefined; |
| 406 | | } |
| 407 | | |
| 408 | | function sdkNativeMethod(message: SDKMessage): string { |
| 409 | | const subtype = sdkMessageSubtype(message); |
| 410 | | if (subtype) { |
| 411 | | return `claude/${message.type}/${subtype}`; |
| 412 | | } |
| 413 | | |
| 414 | | if (message.type === "stream_event") { |
| 415 | | const streamType = sdkMessageType(message.event); |
| 416 | | if (streamType) { |
| 417 | | const deltaType = |
| 418 | | streamType === "content_block_delta" |
| 419 | | ? sdkMessageType((message.event as { delta?: unknown }).delta) |
| 420 | | : undefined; |
| 421 | | if (deltaType) { |
| 422 | | return `claude/${message.type}/${streamType}/${deltaType}`; |
| 423 | | } |
| 424 | | return `claude/${message.type}/${streamType}`; |
| 425 | | } |
| 426 | | } |
| 427 | | |
| 428 | | return `claude/${message.type}`; |
| 429 | | } |
| 430 | | |
| 431 | | function sdkNativeItemId(message: SDKMessage): string | undefined { |
| 432 | | if (message.type === "assistant") { |
| 433 | | const maybeId = (message.message as { id?: unknown }).id; |
| 434 | | if (typeof maybeId === "string") { |
| 435 | | return maybeId; |
| 436 | | } |
| 437 | | return undefined; |
| 438 | | } |
| 439 | | |
| 440 | | if (message.type === "stream_event") { |
| 441 | | const event = message.event as { |
| 442 | | type?: unknown; |
| 443 | | content_block?: { id?: unknown }; |
| 444 | | }; |
| 445 | | if (event.type === "content_block_start" && typeof event.content_block?.id === "string") { |
| 446 | | return event.content_block.id; |
| 447 | | } |
| 448 | | } |
| 449 | | |
| 450 | | return undefined; |
| 451 | | } |
| 452 | | |
| 453 | | function makeClaudeCodeAdapter(options?: ClaudeCodeAdapterLiveOptions) { |
| 454 | | return Effect.gen(function* () { |
| 455 | | const nativeEventLogger = |
| 456 | | options?.nativeEventLogger ?? |
| 457 | | (options?.nativeEventLogPath !== undefined |
| 458 | | ? yield* makeEventNdjsonLogger(options.nativeEventLogPath, { |
| 459 | | stream: "native", |
| 460 | | }) |
| 461 | | : undefined); |
| 462 | | |
| 463 | | const createQuery = |
| 464 | | options?.createQuery ?? |
| 465 | | ((input: { |
| 466 | | readonly prompt: AsyncIterable<SDKUserMessage>; |
| 467 | | readonly options: ClaudeQueryOptions; |
| 468 | | }) => query({ prompt: input.prompt, options: input.options }) as ClaudeQueryRuntime); |
| 469 | | |
| 470 | | const sessions = new Map<ThreadId, ClaudeSessionContext>(); |
| 471 | | const runtimeEventQueue = yield* Queue.unbounded<ProviderRuntimeEvent>(); |
| 472 | | |
| 473 | | const nowIso = Effect.map(DateTime.now, DateTime.formatIso); |
| 474 | | const nextEventId = Effect.map(Random.nextUUIDv4, (id) => EventId.makeUnsafe(id)); |
| 475 | | const makeEventStamp = () => Effect.all({ eventId: nextEventId, createdAt: nowIso }); |
| 476 | | |
| 477 | | const offerRuntimeEvent = (event: ProviderRuntimeEvent): Effect.Effect<void> => |
| 478 | | Queue.offer(runtimeEventQueue, event).pipe(Effect.asVoid); |
| 479 | | |
| 480 | | const logNativeSdkMessage = ( |
| 481 | | context: ClaudeSessionContext, |
| 482 | | message: SDKMessage, |
| 483 | | ): Effect.Effect<void> => |
| 484 | | Effect.gen(function* () { |
| 485 | | if (!nativeEventLogger) { |
| 486 | | return; |
| 487 | | } |
| 488 | | |
| 489 | | const observedAt = new Date().toISOString(); |
| 490 | | const itemId = sdkNativeItemId(message); |
| 491 | | |
| 492 | | yield* nativeEventLogger |
| 493 | | .write( |
| 494 | | { |
| 495 | | observedAt, |
| 496 | | event: { |
| 497 | | id: |
| 498 | | "uuid" in message && typeof message.uuid === "string" |
| 499 | | ? message.uuid |
| 500 | | : crypto.randomUUID(), |
| 501 | | kind: "notification", |
| 502 | | provider: PROVIDER, |
| 503 | | createdAt: observedAt, |
| 504 | | method: sdkNativeMethod(message), |
| 505 | | ...(typeof message.session_id === "string" |
| 506 | | ? { providerThreadId: message.session_id } |
| 507 | | : {}), |
| 508 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 509 | | ...(itemId ? { itemId: ProviderItemId.makeUnsafe(itemId) } : {}), |
| 510 | | payload: message, |
| 511 | | }, |
| 512 | | }, |
| 513 | | null, |
| 514 | | ); |
| 515 | | }); |
| 516 | | |
| 517 | | const snapshotThread = ( |
| 518 | | context: ClaudeSessionContext, |
| 519 | | ): Effect.Effect<{ |
| 520 | | threadId: ThreadId; |
| 521 | | turns: ReadonlyArray<{ |
| 522 | | id: TurnId; |
| 523 | | items: ReadonlyArray<unknown>; |
| 524 | | }>; |
| 525 | | }, ProviderAdapterValidationError> => |
| 526 | | Effect.gen(function* () { |
| 527 | | const threadId = context.session.threadId; |
| 528 | | if (!threadId) { |
| 529 | | return yield* new ProviderAdapterValidationError({ |
| 530 | | provider: PROVIDER, |
| 531 | | operation: "readThread", |
| 532 | | issue: "Session thread id is not initialized yet.", |
| 533 | | }); |
| 534 | | } |
| 535 | | return { |
| 536 | | threadId, |
| 537 | | turns: context.turns.map((turn) => ({ |
| 538 | | id: turn.id, |
| 539 | | items: [...turn.items], |
| 540 | | })), |
| 541 | | }; |
| 542 | | }); |
| 543 | | |
| 544 | | const updateResumeCursor = (context: ClaudeSessionContext): Effect.Effect<void> => |
| 545 | | Effect.gen(function* () { |
| 546 | | const threadId = context.session.threadId; |
| 547 | | if (!threadId) return; |
| 548 | | |
| 549 | | const resumeCursor = { |
| 550 | | threadId, |
| 551 | | ...(context.resumeSessionId ? { resume: context.resumeSessionId } : {}), |
| 552 | | ...(context.lastAssistantUuid ? { resumeSessionAt: context.lastAssistantUuid } : {}), |
| 553 | | turnCount: context.turns.length, |
| 554 | | }; |
| 555 | | |
| 556 | | context.session = { |
| 557 | | ...context.session, |
| 558 | | resumeCursor, |
| 559 | | updatedAt: yield* nowIso, |
| 560 | | }; |
| 561 | | }); |
| 562 | | |
| 563 | | const ensureThreadId = ( |
| 564 | | context: ClaudeSessionContext, |
| 565 | | message: SDKMessage, |
| 566 | | ): Effect.Effect<void> => |
| 567 | | Effect.gen(function* () { |
| 568 | | if (typeof message.session_id !== "string" || message.session_id.length === 0) { |
| 569 | | return; |
| 570 | | } |
| 571 | | const nextThreadId = message.session_id; |
| 572 | | context.resumeSessionId = message.session_id; |
| 573 | | yield* updateResumeCursor(context); |
| 574 | | |
| 575 | | if (context.lastThreadStartedId !== nextThreadId) { |
| 576 | | context.lastThreadStartedId = nextThreadId; |
| 577 | | const stamp = yield* makeEventStamp(); |
| 578 | | yield* offerRuntimeEvent({ |
| 579 | | type: "thread.started", |
| 580 | | eventId: stamp.eventId, |
| 581 | | provider: PROVIDER, |
| 582 | | createdAt: stamp.createdAt, |
| 583 | | threadId: context.session.threadId, |
| 584 | | payload: { |
| 585 | | providerThreadId: nextThreadId, |
| 586 | | }, |
| 587 | | providerRefs: {}, |
| 588 | | raw: { |
| 589 | | source: "claude.sdk.message", |
| 590 | | method: "claude/thread/started", |
| 591 | | payload: { |
| 592 | | session_id: message.session_id, |
| 593 | | }, |
| 594 | | }, |
| 595 | | }); |
| 596 | | } |
| 597 | | }); |
| 598 | | |
| 599 | | const emitRuntimeError = ( |
| 600 | | context: ClaudeSessionContext, |
| 601 | | message: string, |
| 602 | | cause?: unknown, |
| 603 | | ): Effect.Effect<void> => |
| 604 | | Effect.gen(function* () { |
| 605 | | if (cause !== undefined) { |
| 606 | | void cause; |
| 607 | | } |
| 608 | | const turnState = context.turnState; |
| 609 | | const stamp = yield* makeEventStamp(); |
| 610 | | yield* offerRuntimeEvent({ |
| 611 | | type: "runtime.error", |
| 612 | | eventId: stamp.eventId, |
| 613 | | provider: PROVIDER, |
| 614 | | createdAt: stamp.createdAt, |
| 615 | | threadId: context.session.threadId, |
| 616 | | ...(turnState ? { turnId: asCanonicalTurnId(turnState.turnId) } : {}), |
| 617 | | payload: { |
| 618 | | message, |
| 619 | | class: "provider_error", |
| 620 | | ...(cause !== undefined ? { detail: cause } : {}), |
| 621 | | }, |
| 622 | | providerRefs: { |
| 623 | | ...providerThreadRef(context), |
| 624 | | ...(turnState ? { providerTurnId: String(turnState.turnId) } : {}), |
| 625 | | }, |
| 626 | | }); |
| 627 | | }); |
| 628 | | |
| 629 | | const emitRuntimeWarning = ( |
| 630 | | context: ClaudeSessionContext, |
| 631 | | message: string, |
| 632 | | detail?: unknown, |
| 633 | | ): Effect.Effect<void> => |
| 634 | | Effect.gen(function* () { |
| 635 | | const turnState = context.turnState; |
| 636 | | const stamp = yield* makeEventStamp(); |
| 637 | | yield* offerRuntimeEvent({ |
| 638 | | type: "runtime.warning", |
| 639 | | eventId: stamp.eventId, |
| 640 | | provider: PROVIDER, |
| 641 | | createdAt: stamp.createdAt, |
| 642 | | threadId: context.session.threadId, |
| 643 | | ...(turnState ? { turnId: asCanonicalTurnId(turnState.turnId) } : {}), |
| 644 | | payload: { |
| 645 | | message, |
| 646 | | ...(detail !== undefined ? { detail } : {}), |
| 647 | | }, |
| 648 | | providerRefs: { |
| 649 | | ...providerThreadRef(context), |
| 650 | | ...(turnState ? { providerTurnId: String(turnState.turnId) } : {}), |
| 651 | | }, |
| 652 | | }); |
| 653 | | }); |
| 654 | | |
| 655 | | const completeTurn = ( |
| 656 | | context: ClaudeSessionContext, |
| 657 | | status: ProviderRuntimeTurnStatus, |
| 658 | | errorMessage?: string, |
| 659 | | result?: SDKResultMessage, |
| 660 | | ): Effect.Effect<void> => |
| 661 | | Effect.gen(function* () { |
| 662 | | const turnState = context.turnState; |
| 663 | | if (!turnState) { |
| 664 | | const stamp = yield* makeEventStamp(); |
| 665 | | yield* offerRuntimeEvent({ |
| 666 | | type: "turn.completed", |
| 667 | | eventId: stamp.eventId, |
| 668 | | provider: PROVIDER, |
| 669 | | createdAt: stamp.createdAt, |
| 670 | | threadId: context.session.threadId, |
| 671 | | payload: { |
| 672 | | state: status, |
| 673 | | ...(result?.stop_reason !== undefined ? { stopReason: result.stop_reason } : {}), |
| 674 | | ...(result?.usage ? { usage: result.usage } : {}), |
| 675 | | ...(result?.modelUsage ? { modelUsage: result.modelUsage } : {}), |
| 676 | | ...(typeof result?.total_cost_usd === "number" |
| 677 | | ? { totalCostUsd: result.total_cost_usd } |
| 678 | | : {}), |
| 679 | | ...(errorMessage ? { errorMessage } : {}), |
| 680 | | }, |
| 681 | | providerRefs: {}, |
| 682 | | }); |
| 683 | | return; |
| 684 | | } |
| 685 | | |
| 686 | | if (!turnState.messageCompleted) { |
| 687 | | if (!turnState.emittedTextDelta && turnState.fallbackAssistantText.length > 0) { |
| 688 | | const deltaStamp = yield* makeEventStamp(); |
| 689 | | yield* offerRuntimeEvent({ |
| 690 | | type: "content.delta", |
| 691 | | eventId: deltaStamp.eventId, |
| 692 | | provider: PROVIDER, |
| 693 | | createdAt: deltaStamp.createdAt, |
| 694 | | threadId: context.session.threadId, |
| 695 | | turnId: turnState.turnId, |
| 696 | | itemId: asRuntimeItemId(turnState.assistantItemId), |
| 697 | | payload: { |
| 698 | | streamKind: "assistant_text", |
| 699 | | delta: turnState.fallbackAssistantText, |
| 700 | | }, |
| 701 | | providerRefs: { |
| 702 | | ...providerThreadRef(context), |
| 703 | | providerTurnId: String(turnState.turnId), |
| 704 | | providerItemId: ProviderItemId.makeUnsafe(turnState.assistantItemId), |
| 705 | | }, |
| 706 | | }); |
| 707 | | } |
| 708 | | |
| 709 | | const stamp = yield* makeEventStamp(); |
| 710 | | yield* offerRuntimeEvent({ |
| 711 | | type: "item.completed", |
| 712 | | eventId: stamp.eventId, |
| 713 | | provider: PROVIDER, |
| 714 | | createdAt: stamp.createdAt, |
| 715 | | itemId: asRuntimeItemId(turnState.assistantItemId), |
| 716 | | threadId: context.session.threadId, |
| 717 | | turnId: turnState.turnId, |
| 718 | | payload: { |
| 719 | | itemType: "assistant_message", |
| 720 | | status: "completed", |
| 721 | | title: "Assistant message", |
| 722 | | }, |
| 723 | | providerRefs: { |
| 724 | | ...providerThreadRef(context), |
| 725 | | providerTurnId: turnState.turnId, |
| 726 | | providerItemId: ProviderItemId.makeUnsafe(turnState.assistantItemId), |
| 727 | | }, |
| 728 | | }); |
| 729 | | } |
| 730 | | |
| 731 | | context.turns.push({ |
| 732 | | id: turnState.turnId, |
| 733 | | items: [...turnState.items], |
| 734 | | }); |
| 735 | | |
| 736 | | const stamp = yield* makeEventStamp(); |
| 737 | | yield* offerRuntimeEvent({ |
| 738 | | type: "turn.completed", |
| 739 | | eventId: stamp.eventId, |
| 740 | | provider: PROVIDER, |
| 741 | | createdAt: stamp.createdAt, |
| 742 | | threadId: context.session.threadId, |
| 743 | | turnId: turnState.turnId, |
| 744 | | payload: { |
| 745 | | state: status, |
| 746 | | ...(result?.stop_reason !== undefined ? { stopReason: result.stop_reason } : {}), |
| 747 | | ...(result?.usage ? { usage: result.usage } : {}), |
| 748 | | ...(result?.modelUsage ? { modelUsage: result.modelUsage } : {}), |
| 749 | | ...(typeof result?.total_cost_usd === "number" |
| 750 | | ? { totalCostUsd: result.total_cost_usd } |
| 751 | | : {}), |
| 752 | | ...(errorMessage ? { errorMessage } : {}), |
| 753 | | }, |
| 754 | | providerRefs: { |
| 755 | | ...providerThreadRef(context), |
| 756 | | providerTurnId: turnState.turnId, |
| 757 | | }, |
| 758 | | }); |
| 759 | | |
| 760 | | const updatedAt = yield* nowIso; |
| 761 | | context.turnState = undefined; |
| 762 | | context.session = { |
| 763 | | ...context.session, |
| 764 | | status: "ready", |
| 765 | | activeTurnId: undefined, |
| 766 | | updatedAt, |
| 767 | | ...(status === "failed" && errorMessage ? { lastError: errorMessage } : {}), |
| 768 | | }; |
| 769 | | yield* updateResumeCursor(context); |
| 770 | | }); |
| 771 | | |
| 772 | | const handleStreamEvent = ( |
| 773 | | context: ClaudeSessionContext, |
| 774 | | message: SDKMessage, |
| 775 | | ): Effect.Effect<void> => |
| 776 | | Effect.gen(function* () { |
| 777 | | if (message.type !== "stream_event") { |
| 778 | | return; |
| 779 | | } |
| 780 | | |
| 781 | | const { event } = message; |
| 782 | | |
| 783 | | if (event.type === "content_block_delta") { |
| 784 | | if ( |
| 785 | | event.delta.type === "text_delta" && |
| 786 | | event.delta.text.length > 0 && |
| 787 | | context.turnState |
| 788 | | ) { |
| 789 | | if (!context.turnState.emittedTextDelta) { |
| 790 | | context.turnState = { |
| 791 | | ...context.turnState, |
| 792 | | emittedTextDelta: true, |
| 793 | | }; |
| 794 | | } |
| 795 | | const stamp = yield* makeEventStamp(); |
| 796 | | yield* offerRuntimeEvent({ |
| 797 | | type: "content.delta", |
| 798 | | eventId: stamp.eventId, |
| 799 | | provider: PROVIDER, |
| 800 | | createdAt: stamp.createdAt, |
| 801 | | threadId: context.session.threadId, |
| 802 | | turnId: context.turnState.turnId, |
| 803 | | itemId: asRuntimeItemId(context.turnState.assistantItemId), |
| 804 | | payload: { |
| 805 | | streamKind: streamKindFromDeltaType(event.delta.type), |
| 806 | | delta: event.delta.text, |
| 807 | | }, |
| 808 | | providerRefs: { |
| 809 | | ...providerThreadRef(context), |
| 810 | | providerTurnId: context.turnState.turnId, |
| 811 | | providerItemId: ProviderItemId.makeUnsafe(context.turnState.assistantItemId), |
| 812 | | }, |
| 813 | | raw: { |
| 814 | | source: "claude.sdk.message", |
| 815 | | method: "claude/stream_event/content_block_delta", |
| 816 | | payload: message, |
| 817 | | }, |
| 818 | | }); |
| 819 | | } |
| 820 | | return; |
| 821 | | } |
| 822 | | |
| 823 | | if (event.type === "content_block_start") { |
| 824 | | const { index, content_block: block } = event; |
| 825 | | if ( |
| 826 | | block.type !== "tool_use" && |
| 827 | | block.type !== "server_tool_use" && |
| 828 | | block.type !== "mcp_tool_use" |
| 829 | | ) { |
| 830 | | return; |
| 831 | | } |
| 832 | | |
| 833 | | const toolName = block.name; |
| 834 | | const itemType = classifyToolItemType(toolName); |
| 835 | | const toolInput = |
| 836 | | typeof block.input === "object" && block.input !== null |
| 837 | | ? (block.input as Record<string, unknown>) |
| 838 | | : {}; |
| 839 | | const itemId = block.id; |
| 840 | | const detail = summarizeToolRequest(toolName, toolInput); |
| 841 | | |
| 842 | | const tool: ToolInFlight = { |
| 843 | | itemId, |
| 844 | | itemType, |
| 845 | | toolName, |
| 846 | | title: titleForTool(itemType), |
| 847 | | detail, |
| 848 | | }; |
| 849 | | context.inFlightTools.set(index, tool); |
| 850 | | |
| 851 | | const stamp = yield* makeEventStamp(); |
| 852 | | yield* offerRuntimeEvent({ |
| 853 | | type: "item.started", |
| 854 | | eventId: stamp.eventId, |
| 855 | | provider: PROVIDER, |
| 856 | | createdAt: stamp.createdAt, |
| 857 | | threadId: context.session.threadId, |
| 858 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 859 | | itemId: asRuntimeItemId(tool.itemId), |
| 860 | | payload: { |
| 861 | | itemType: tool.itemType, |
| 862 | | status: "inProgress", |
| 863 | | title: tool.title, |
| 864 | | ...(tool.detail ? { detail: tool.detail } : {}), |
| 865 | | data: { |
| 866 | | toolName: tool.toolName, |
| 867 | | input: toolInput, |
| 868 | | }, |
| 869 | | }, |
| 870 | | providerRefs: { |
| 871 | | ...providerThreadRef(context), |
| 872 | | ...(context.turnState ? { providerTurnId: String(context.turnState.turnId) } : {}), |
| 873 | | providerItemId: ProviderItemId.makeUnsafe(tool.itemId), |
| 874 | | }, |
| 875 | | raw: { |
| 876 | | source: "claude.sdk.message", |
| 877 | | method: "claude/stream_event/content_block_start", |
| 878 | | payload: message, |
| 879 | | }, |
| 880 | | }); |
| 881 | | return; |
| 882 | | } |
| 883 | | |
| 884 | | if (event.type === "content_block_stop") { |
| 885 | | const { index } = event; |
| 886 | | const tool = context.inFlightTools.get(index); |
| 887 | | if (!tool) { |
| 888 | | return; |
| 889 | | } |
| 890 | | context.inFlightTools.delete(index); |
| 891 | | |
| 892 | | const stamp = yield* makeEventStamp(); |
| 893 | | yield* offerRuntimeEvent({ |
| 894 | | type: "item.completed", |
| 895 | | eventId: stamp.eventId, |
| 896 | | provider: PROVIDER, |
| 897 | | createdAt: stamp.createdAt, |
| 898 | | threadId: context.session.threadId, |
| 899 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 900 | | itemId: asRuntimeItemId(tool.itemId), |
| 901 | | payload: { |
| 902 | | itemType: tool.itemType, |
| 903 | | status: "completed", |
| 904 | | title: tool.title, |
| 905 | | ...(tool.detail ? { detail: tool.detail } : {}), |
| 906 | | }, |
| 907 | | providerRefs: { |
| 908 | | ...providerThreadRef(context), |
| 909 | | ...(context.turnState ? { providerTurnId: String(context.turnState.turnId) } : {}), |
| 910 | | providerItemId: ProviderItemId.makeUnsafe(tool.itemId), |
| 911 | | }, |
| 912 | | raw: { |
| 913 | | source: "claude.sdk.message", |
| 914 | | method: "claude/stream_event/content_block_stop", |
| 915 | | payload: message, |
| 916 | | }, |
| 917 | | }); |
| 918 | | } |
| 919 | | }); |
| 920 | | |
| 921 | | const handleAssistantMessage = ( |
| 922 | | context: ClaudeSessionContext, |
| 923 | | message: SDKMessage, |
| 924 | | ): Effect.Effect<void> => |
| 925 | | Effect.gen(function* () { |
| 926 | | if (message.type !== "assistant") { |
| 927 | | return; |
| 928 | | } |
| 929 | | |
| 930 | | if (context.turnState) { |
| 931 | | context.turnState.items.push(message.message); |
| 932 | | const fallbackAssistantText = extractAssistantText(message); |
| 933 | | if ( |
| 934 | | fallbackAssistantText.length > 0 && |
| 935 | | fallbackAssistantText !== context.turnState.fallbackAssistantText |
| 936 | | ) { |
| 937 | | context.turnState = { |
| 938 | | ...context.turnState, |
| 939 | | fallbackAssistantText, |
| 940 | | }; |
| 941 | | } |
| 942 | | |
| 943 | | const stamp = yield* makeEventStamp(); |
| 944 | | yield* offerRuntimeEvent({ |
| 945 | | type: "item.updated", |
| 946 | | eventId: stamp.eventId, |
| 947 | | provider: PROVIDER, |
| 948 | | createdAt: stamp.createdAt, |
| 949 | | threadId: context.session.threadId, |
| 950 | | turnId: context.turnState.turnId, |
| 951 | | itemId: asRuntimeItemId(context.turnState.assistantItemId), |
| 952 | | payload: { |
| 953 | | itemType: "assistant_message", |
| 954 | | status: "inProgress", |
| 955 | | title: "Assistant message", |
| 956 | | data: message.message, |
| 957 | | }, |
| 958 | | providerRefs: { |
| 959 | | ...providerThreadRef(context), |
| 960 | | providerTurnId: context.turnState.turnId, |
| 961 | | providerItemId: ProviderItemId.makeUnsafe(context.turnState.assistantItemId), |
| 962 | | }, |
| 963 | | raw: { |
| 964 | | source: "claude.sdk.message", |
| 965 | | method: "claude/assistant", |
| 966 | | payload: message, |
| 967 | | }, |
| 968 | | }); |
| 969 | | } |
| 970 | | |
| 971 | | context.lastAssistantUuid = message.uuid; |
| 972 | | yield* updateResumeCursor(context); |
| 973 | | }); |
| 974 | | |
| 975 | | const handleResultMessage = ( |
| 976 | | context: ClaudeSessionContext, |
| 977 | | message: SDKMessage, |
| 978 | | ): Effect.Effect<void> => |
| 979 | | Effect.gen(function* () { |
| 980 | | if (message.type !== "result") { |
| 981 | | return; |
| 982 | | } |
| 983 | | |
| 984 | | const status = turnStatusFromResult(message); |
| 985 | | const errorMessage = message.subtype === "success" ? undefined : message.errors[0]; |
| 986 | | |
| 987 | | if (status === "failed") { |
| 988 | | yield* emitRuntimeError(context, errorMessage ?? "Claude turn failed."); |
| 989 | | } |
| 990 | | |
| 991 | | yield* completeTurn(context, status, errorMessage, message); |
| 992 | | }); |
| 993 | | |
| 994 | | const handleSystemMessage = ( |
| 995 | | context: ClaudeSessionContext, |
| 996 | | message: SDKMessage, |
| 997 | | ): Effect.Effect<void> => |
| 998 | | Effect.gen(function* () { |
| 999 | | if (message.type !== "system") { |
| 1000 | | return; |
| 1001 | | } |
| 1002 | | |
| 1003 | | const stamp = yield* makeEventStamp(); |
| 1004 | | const base = { |
| 1005 | | eventId: stamp.eventId, |
| 1006 | | provider: PROVIDER, |
| 1007 | | createdAt: stamp.createdAt, |
| 1008 | | threadId: context.session.threadId, |
| 1009 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 1010 | | providerRefs: { |
| 1011 | | ...providerThreadRef(context), |
| 1012 | | ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}), |
| 1013 | | }, |
| 1014 | | raw: { |
| 1015 | | source: "claude.sdk.message" as const, |
| 1016 | | method: sdkNativeMethod(message), |
| 1017 | | messageType: `${message.type}:${message.subtype}`, |
| 1018 | | payload: message, |
| 1019 | | }, |
| 1020 | | }; |
| 1021 | | |
| 1022 | | switch (message.subtype) { |
| 1023 | | case "init": |
| 1024 | | yield* offerRuntimeEvent({ |
| 1025 | | ...base, |
| 1026 | | type: "session.configured", |
| 1027 | | payload: { |
| 1028 | | config: message as Record<string, unknown>, |
| 1029 | | }, |
| 1030 | | }); |
| 1031 | | return; |
| 1032 | | case "status": |
| 1033 | | yield* offerRuntimeEvent({ |
| 1034 | | ...base, |
| 1035 | | type: "session.state.changed", |
| 1036 | | payload: { |
| 1037 | | state: message.status === "compacting" ? "waiting" : "running", |
| 1038 | | reason: `status:${message.status ?? "active"}`, |
| 1039 | | detail: message, |
| 1040 | | }, |
| 1041 | | }); |
| 1042 | | return; |
| 1043 | | case "compact_boundary": |
| 1044 | | yield* offerRuntimeEvent({ |
| 1045 | | ...base, |
| 1046 | | type: "thread.state.changed", |
| 1047 | | payload: { |
| 1048 | | state: "compacted", |
| 1049 | | detail: message, |
| 1050 | | }, |
| 1051 | | }); |
| 1052 | | return; |
| 1053 | | case "hook_started": |
| 1054 | | yield* offerRuntimeEvent({ |
| 1055 | | ...base, |
| 1056 | | type: "hook.started", |
| 1057 | | payload: { |
| 1058 | | hookId: message.hook_id, |
| 1059 | | hookName: message.hook_name, |
| 1060 | | hookEvent: message.hook_event, |
| 1061 | | }, |
| 1062 | | }); |
| 1063 | | return; |
| 1064 | | case "hook_progress": |
| 1065 | | yield* offerRuntimeEvent({ |
| 1066 | | ...base, |
| 1067 | | type: "hook.progress", |
| 1068 | | payload: { |
| 1069 | | hookId: message.hook_id, |
| 1070 | | output: message.output, |
| 1071 | | stdout: message.stdout, |
| 1072 | | stderr: message.stderr, |
| 1073 | | }, |
| 1074 | | }); |
| 1075 | | return; |
| 1076 | | case "hook_response": |
| 1077 | | yield* offerRuntimeEvent({ |
| 1078 | | ...base, |
| 1079 | | type: "hook.completed", |
| 1080 | | payload: { |
| 1081 | | hookId: message.hook_id, |
| 1082 | | outcome: message.outcome, |
| 1083 | | output: message.output, |
| 1084 | | stdout: message.stdout, |
| 1085 | | stderr: message.stderr, |
| 1086 | | ...(typeof message.exit_code === "number" ? { exitCode: message.exit_code } : {}), |
| 1087 | | }, |
| 1088 | | }); |
| 1089 | | return; |
| 1090 | | case "task_started": |
| 1091 | | yield* offerRuntimeEvent({ |
| 1092 | | ...base, |
| 1093 | | type: "task.started", |
| 1094 | | payload: { |
| 1095 | | taskId: RuntimeTaskId.makeUnsafe(message.task_id), |
| 1096 | | description: message.description, |
| 1097 | | ...(message.task_type ? { taskType: message.task_type } : {}), |
| 1098 | | }, |
| 1099 | | }); |
| 1100 | | return; |
| 1101 | | case "task_progress": |
| 1102 | | yield* offerRuntimeEvent({ |
| 1103 | | ...base, |
| 1104 | | type: "task.progress", |
| 1105 | | payload: { |
| 1106 | | taskId: RuntimeTaskId.makeUnsafe(message.task_id), |
| 1107 | | description: message.description, |
| 1108 | | ...(message.usage ? { usage: message.usage } : {}), |
| 1109 | | ...(message.last_tool_name ? { lastToolName: message.last_tool_name } : {}), |
| 1110 | | }, |
| 1111 | | }); |
| 1112 | | return; |
| 1113 | | case "task_notification": |
| 1114 | | yield* offerRuntimeEvent({ |
| 1115 | | ...base, |
| 1116 | | type: "task.completed", |
| 1117 | | payload: { |
| 1118 | | taskId: RuntimeTaskId.makeUnsafe(message.task_id), |
| 1119 | | status: message.status, |
| 1120 | | ...(message.summary ? { summary: message.summary } : {}), |
| 1121 | | ...(message.usage ? { usage: message.usage } : {}), |
| 1122 | | }, |
| 1123 | | }); |
| 1124 | | return; |
| 1125 | | case "files_persisted": |
| 1126 | | yield* offerRuntimeEvent({ |
| 1127 | | ...base, |
| 1128 | | type: "files.persisted", |
| 1129 | | payload: { |
| 1130 | | files: Array.isArray(message.files) |
| 1131 | | ? message.files.map((file: { filename: string; file_id: string }) => ({ |
| 1132 | | filename: file.filename, |
| 1133 | | fileId: file.file_id, |
| 1134 | | })) |
| 1135 | | : [], |
| 1136 | | ...(Array.isArray(message.failed) |
| 1137 | | ? { |
| 1138 | | failed: message.failed.map((entry: { filename: string; error: string }) => ({ |
| 1139 | | filename: entry.filename, |
| 1140 | | error: entry.error, |
| 1141 | | })), |
| 1142 | | } |
| 1143 | | : {}), |
| 1144 | | }, |
| 1145 | | }); |
| 1146 | | return; |
| 1147 | | default: |
| 1148 | | yield* emitRuntimeWarning( |
| 1149 | | context, |
| 1150 | | `Unhandled Claude system message subtype '${message.subtype}'.`, |
| 1151 | | message, |
| 1152 | | ); |
| 1153 | | return; |
| 1154 | | } |
| 1155 | | }); |
| 1156 | | |
| 1157 | | const handleSdkTelemetryMessage = ( |
| 1158 | | context: ClaudeSessionContext, |
| 1159 | | message: SDKMessage, |
| 1160 | | ): Effect.Effect<void> => |
| 1161 | | Effect.gen(function* () { |
| 1162 | | const stamp = yield* makeEventStamp(); |
| 1163 | | const base = { |
| 1164 | | eventId: stamp.eventId, |
| 1165 | | provider: PROVIDER, |
| 1166 | | createdAt: stamp.createdAt, |
| 1167 | | threadId: context.session.threadId, |
| 1168 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 1169 | | providerRefs: { |
| 1170 | | ...providerThreadRef(context), |
| 1171 | | ...(context.turnState ? { providerTurnId: context.turnState.turnId } : {}), |
| 1172 | | }, |
| 1173 | | raw: { |
| 1174 | | source: "claude.sdk.message" as const, |
| 1175 | | method: sdkNativeMethod(message), |
| 1176 | | messageType: message.type, |
| 1177 | | payload: message, |
| 1178 | | }, |
| 1179 | | }; |
| 1180 | | |
| 1181 | | if (message.type === "tool_progress") { |
| 1182 | | yield* offerRuntimeEvent({ |
| 1183 | | ...base, |
| 1184 | | type: "tool.progress", |
| 1185 | | payload: { |
| 1186 | | toolUseId: message.tool_use_id, |
| 1187 | | toolName: message.tool_name, |
| 1188 | | elapsedSeconds: message.elapsed_time_seconds, |
| 1189 | | ...(message.task_id ? { summary: `task:${message.task_id}` } : {}), |
| 1190 | | }, |
| 1191 | | }); |
| 1192 | | return; |
| 1193 | | } |
| 1194 | | |
| 1195 | | if (message.type === "tool_use_summary") { |
| 1196 | | yield* offerRuntimeEvent({ |
| 1197 | | ...base, |
| 1198 | | type: "tool.summary", |
| 1199 | | payload: { |
| 1200 | | summary: message.summary, |
| 1201 | | ...(message.preceding_tool_use_ids.length > 0 |
| 1202 | | ? { precedingToolUseIds: message.preceding_tool_use_ids } |
| 1203 | | : {}), |
| 1204 | | }, |
| 1205 | | }); |
| 1206 | | return; |
| 1207 | | } |
| 1208 | | |
| 1209 | | if (message.type === "auth_status") { |
| 1210 | | yield* offerRuntimeEvent({ |
| 1211 | | ...base, |
| 1212 | | type: "auth.status", |
| 1213 | | payload: { |
| 1214 | | isAuthenticating: message.isAuthenticating, |
| 1215 | | output: message.output, |
| 1216 | | ...(message.error ? { error: message.error } : {}), |
| 1217 | | }, |
| 1218 | | }); |
| 1219 | | return; |
| 1220 | | } |
| 1221 | | |
| 1222 | | if (message.type === "rate_limit_event") { |
| 1223 | | yield* offerRuntimeEvent({ |
| 1224 | | ...base, |
| 1225 | | type: "account.rate-limits.updated", |
| 1226 | | payload: { |
| 1227 | | rateLimits: message, |
| 1228 | | }, |
| 1229 | | }); |
| 1230 | | return; |
| 1231 | | } |
| 1232 | | }); |
| 1233 | | |
| 1234 | | const handleSdkMessage = ( |
| 1235 | | context: ClaudeSessionContext, |
| 1236 | | message: SDKMessage, |
| 1237 | | ): Effect.Effect<void> => |
| 1238 | | Effect.gen(function* () { |
| 1239 | | yield* logNativeSdkMessage(context, message); |
| 1240 | | yield* ensureThreadId(context, message); |
| 1241 | | |
| 1242 | | switch (message.type) { |
| 1243 | | case "stream_event": |
| 1244 | | yield* handleStreamEvent(context, message); |
| 1245 | | return; |
| 1246 | | case "user": |
| 1247 | | return; |
| 1248 | | case "assistant": |
| 1249 | | yield* handleAssistantMessage(context, message); |
| 1250 | | return; |
| 1251 | | case "result": |
| 1252 | | yield* handleResultMessage(context, message); |
| 1253 | | return; |
| 1254 | | case "system": |
| 1255 | | yield* handleSystemMessage(context, message); |
| 1256 | | return; |
| 1257 | | case "tool_progress": |
| 1258 | | case "tool_use_summary": |
| 1259 | | case "auth_status": |
| 1260 | | case "rate_limit_event": |
| 1261 | | yield* handleSdkTelemetryMessage(context, message); |
| 1262 | | return; |
| 1263 | | default: |
| 1264 | | yield* emitRuntimeWarning( |
| 1265 | | context, |
| 1266 | | `Unhandled Claude SDK message type '${message.type}'.`, |
| 1267 | | message, |
| 1268 | | ); |
| 1269 | | return; |
| 1270 | | } |
| 1271 | | }); |
| 1272 | | |
| 1273 | | const runSdkStream = (context: ClaudeSessionContext): Effect.Effect<void> => |
| 1274 | | Stream.fromAsyncIterable(context.query, (cause) => cause).pipe( |
| 1275 | | Stream.takeWhile(() => !context.stopped), |
| 1276 | | Stream.runForEach((message) => handleSdkMessage(context, message)), |
| 1277 | | Effect.catchCause((cause) => |
| 1278 | | Effect.gen(function* () { |
| 1279 | | if (Cause.hasInterruptsOnly(cause) || context.stopped) { |
| 1280 | | return; |
| 1281 | | } |
| 1282 | | const message = toMessage(Cause.squash(cause), "Claude runtime stream failed."); |
| 1283 | | yield* emitRuntimeError(context, message, cause); |
| 1284 | | yield* completeTurn(context, "failed", message); |
| 1285 | | }), |
| 1286 | | ), |
| 1287 | | ); |
| 1288 | | |
| 1289 | | const stopSessionInternal = ( |
| 1290 | | context: ClaudeSessionContext, |
| 1291 | | options?: { readonly emitExitEvent?: boolean }, |
| 1292 | | ): Effect.Effect<void> => |
| 1293 | | Effect.gen(function* () { |
| 1294 | | if (context.stopped) return; |
| 1295 | | |
| 1296 | | context.stopped = true; |
| 1297 | | |
| 1298 | | for (const [requestId, pending] of context.pendingApprovals) { |
| 1299 | | yield* Deferred.succeed(pending.decision, "cancel"); |
| 1300 | | const stamp = yield* makeEventStamp(); |
| 1301 | | yield* offerRuntimeEvent({ |
| 1302 | | type: "request.resolved", |
| 1303 | | eventId: stamp.eventId, |
| 1304 | | provider: PROVIDER, |
| 1305 | | createdAt: stamp.createdAt, |
| 1306 | | threadId: context.session.threadId, |
| 1307 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 1308 | | requestId: asRuntimeRequestId(requestId), |
| 1309 | | payload: { |
| 1310 | | requestType: pending.requestType, |
| 1311 | | decision: "cancel", |
| 1312 | | }, |
| 1313 | | providerRefs: { |
| 1314 | | ...providerThreadRef(context), |
| 1315 | | ...(context.turnState ? { providerTurnId: String(context.turnState.turnId) } : {}), |
| 1316 | | providerRequestId: requestId, |
| 1317 | | }, |
| 1318 | | }); |
| 1319 | | } |
| 1320 | | context.pendingApprovals.clear(); |
| 1321 | | |
| 1322 | | if (context.turnState) { |
| 1323 | | yield* completeTurn(context, "interrupted", "Session stopped."); |
| 1324 | | } |
| 1325 | | |
| 1326 | | yield* Queue.shutdown(context.promptQueue); |
| 1327 | | |
| 1328 | | context.query.close(); |
| 1329 | | |
| 1330 | | const updatedAt = yield* nowIso; |
| 1331 | | context.session = { |
| 1332 | | ...context.session, |
| 1333 | | status: "closed", |
| 1334 | | activeTurnId: undefined, |
| 1335 | | updatedAt, |
| 1336 | | }; |
| 1337 | | |
| 1338 | | if (options?.emitExitEvent !== false) { |
| 1339 | | const stamp = yield* makeEventStamp(); |
| 1340 | | yield* offerRuntimeEvent({ |
| 1341 | | type: "session.exited", |
| 1342 | | eventId: stamp.eventId, |
| 1343 | | provider: PROVIDER, |
| 1344 | | createdAt: stamp.createdAt, |
| 1345 | | threadId: context.session.threadId, |
| 1346 | | payload: { |
| 1347 | | reason: "Session stopped", |
| 1348 | | exitKind: "graceful", |
| 1349 | | }, |
| 1350 | | providerRefs: {}, |
| 1351 | | }); |
| 1352 | | } |
| 1353 | | |
| 1354 | | sessions.delete(context.session.threadId); |
| 1355 | | }); |
| 1356 | | |
| 1357 | | const requireSession = ( |
| 1358 | | threadId: ThreadId, |
| 1359 | | ): Effect.Effect<ClaudeSessionContext, ProviderAdapterError> => { |
| 1360 | | const context = sessions.get(threadId); |
| 1361 | | if (!context) { |
| 1362 | | return Effect.fail( |
| 1363 | | new ProviderAdapterSessionNotFoundError({ |
| 1364 | | provider: PROVIDER, |
| 1365 | | threadId, |
| 1366 | | }), |
| 1367 | | ); |
| 1368 | | } |
| 1369 | | if (context.stopped || context.session.status === "closed") { |
| 1370 | | return Effect.fail( |
| 1371 | | new ProviderAdapterSessionClosedError({ |
| 1372 | | provider: PROVIDER, |
| 1373 | | threadId, |
| 1374 | | }), |
| 1375 | | ); |
| 1376 | | } |
| 1377 | | return Effect.succeed(context); |
| 1378 | | }; |
| 1379 | | |
| 1380 | | const startSession: ClaudeCodeAdapterShape["startSession"] = (input) => |
| 1381 | | Effect.gen(function* () { |
| 1382 | | if (input.provider !== undefined && input.provider !== PROVIDER) { |
| 1383 | | return yield* new ProviderAdapterValidationError({ |
| 1384 | | provider: PROVIDER, |
| 1385 | | operation: "startSession", |
| 1386 | | issue: `Expected provider '${PROVIDER}' but received '${input.provider}'.`, |
| 1387 | | }); |
| 1388 | | } |
| 1389 | | |
| 1390 | | const startedAt = yield* nowIso; |
| 1391 | | const resumeState = readClaudeResumeState(input.resumeCursor); |
| 1392 | | const threadId = input.threadId; |
| 1393 | | |
| 1394 | | const promptQueue = yield* Queue.unbounded<PromptQueueItem>(); |
| 1395 | | const prompt = Stream.fromQueue(promptQueue).pipe( |
| 1396 | | Stream.filter((item) => item.type === "message"), |
| 1397 | | Stream.map((item) => item.message), |
| 1398 | | Stream.toAsyncIterable, |
| 1399 | | ); |
| 1400 | | |
| 1401 | | const pendingApprovals = new Map<ApprovalRequestId, PendingApproval>(); |
| 1402 | | const inFlightTools = new Map<number, ToolInFlight>(); |
| 1403 | | |
| 1404 | | const contextRef = yield* Ref.make<ClaudeSessionContext | undefined>(undefined); |
| 1405 | | |
| 1406 | | const canUseTool: CanUseTool = (toolName, toolInput, callbackOptions) => |
| 1407 | | Effect.runPromise( |
| 1408 | | Effect.gen(function* () { |
| 1409 | | const context = yield* Ref.get(contextRef); |
| 1410 | | if (!context) { |
| 1411 | | return { |
| 1412 | | behavior: "deny", |
| 1413 | | message: "Claude session context is unavailable.", |
| 1414 | | } satisfies PermissionResult; |
| 1415 | | } |
| 1416 | | |
| 1417 | | const runtimeMode = input.runtimeMode ?? "full-access"; |
| 1418 | | if (runtimeMode === "full-access") { |
| 1419 | | return { |
| 1420 | | behavior: "allow", |
| 1421 | | updatedInput: toolInput, |
| 1422 | | } satisfies PermissionResult; |
| 1423 | | } |
| 1424 | | |
| 1425 | | const requestId = ApprovalRequestId.makeUnsafe(yield* Random.nextUUIDv4); |
| 1426 | | const requestType = classifyRequestType(toolName); |
| 1427 | | const detail = summarizeToolRequest(toolName, toolInput); |
| 1428 | | const decisionDeferred = yield* Deferred.make<ProviderApprovalDecision>(); |
| 1429 | | const pendingApproval: PendingApproval = { |
| 1430 | | requestType, |
| 1431 | | detail, |
| 1432 | | decision: decisionDeferred, |
| 1433 | | ...(callbackOptions.suggestions |
| 1434 | | ? { suggestions: callbackOptions.suggestions } |
| 1435 | | : {}), |
| 1436 | | }; |
| 1437 | | |
| 1438 | | const requestedStamp = yield* makeEventStamp(); |
| 1439 | | yield* offerRuntimeEvent({ |
| 1440 | | type: "request.opened", |
| 1441 | | eventId: requestedStamp.eventId, |
| 1442 | | provider: PROVIDER, |
| 1443 | | createdAt: requestedStamp.createdAt, |
| 1444 | | threadId: context.session.threadId, |
| 1445 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 1446 | | requestId: asRuntimeRequestId(requestId), |
| 1447 | | payload: { |
| 1448 | | requestType, |
| 1449 | | detail, |
| 1450 | | args: { |
| 1451 | | toolName, |
| 1452 | | input: toolInput, |
| 1453 | | ...(callbackOptions.toolUseID ? { toolUseId: callbackOptions.toolUseID } : {}), |
| 1454 | | }, |
| 1455 | | }, |
| 1456 | | providerRefs: { |
| 1457 | | ...(context.session.threadId |
| 1458 | | ? { providerThreadId: context.session.threadId } |
| 1459 | | : {}), |
| 1460 | | ...(context.turnState ? { providerTurnId: String(context.turnState.turnId) } : {}), |
| 1461 | | providerRequestId: requestId, |
| 1462 | | }, |
| 1463 | | raw: { |
| 1464 | | source: "claude.sdk.permission", |
| 1465 | | method: "canUseTool/request", |
| 1466 | | payload: { |
| 1467 | | toolName, |
| 1468 | | input: toolInput, |
| 1469 | | }, |
| 1470 | | }, |
| 1471 | | }); |
| 1472 | | |
| 1473 | | pendingApprovals.set(requestId, pendingApproval); |
| 1474 | | |
| 1475 | | const onAbort = () => { |
| 1476 | | if (!pendingApprovals.has(requestId)) { |
| 1477 | | return; |
| 1478 | | } |
| 1479 | | pendingApprovals.delete(requestId); |
| 1480 | | Effect.runFork(Deferred.succeed(decisionDeferred, "cancel")); |
| 1481 | | }; |
| 1482 | | |
| 1483 | | callbackOptions.signal.addEventListener("abort", onAbort, { |
| 1484 | | once: true, |
| 1485 | | }); |
| 1486 | | |
| 1487 | | const decision = yield* Deferred.await(decisionDeferred); |
| 1488 | | pendingApprovals.delete(requestId); |
| 1489 | | |
| 1490 | | const resolvedStamp = yield* makeEventStamp(); |
| 1491 | | yield* offerRuntimeEvent({ |
| 1492 | | type: "request.resolved", |
| 1493 | | eventId: resolvedStamp.eventId, |
| 1494 | | provider: PROVIDER, |
| 1495 | | createdAt: resolvedStamp.createdAt, |
| 1496 | | threadId: context.session.threadId, |
| 1497 | | ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}), |
| 1498 | | requestId: asRuntimeRequestId(requestId), |
| 1499 | | payload: { |
| 1500 | | requestType, |
| 1501 | | decision, |
| 1502 | | }, |
| 1503 | | providerRefs: { |
| 1504 | | ...(context.session.threadId |
| 1505 | | ? { providerThreadId: context.session.threadId } |
| 1506 | | : {}), |
| 1507 | | ...(context.turnState ? { providerTurnId: String(context.turnState.turnId) } : {}), |
| 1508 | | providerRequestId: requestId, |
| 1509 | | }, |
| 1510 | | raw: { |
| 1511 | | source: "claude.sdk.permission", |
| 1512 | | method: "canUseTool/decision", |
| 1513 | | payload: { |
| 1514 | | decision, |
| 1515 | | }, |
| 1516 | | }, |
| 1517 | | }); |
| 1518 | | |
| 1519 | | if (decision === "accept" || decision === "acceptForSession") { |
| 1520 | | return { |
| 1521 | | behavior: "allow", |
| 1522 | | updatedInput: toolInput, |
| 1523 | | ...(decision === "acceptForSession" && pendingApproval.suggestions |
| 1524 | | ? { updatedPermissions: [...pendingApproval.suggestions] } |
| 1525 | | : {}), |
| 1526 | | } satisfies PermissionResult; |
| 1527 | | } |
| 1528 | | |
| 1529 | | return { |
| 1530 | | behavior: "deny", |
| 1531 | | message: |
| 1532 | | decision === "cancel" |
| 1533 | | ? "User cancelled tool execution." |
| 1534 | | : "User declined tool execution.", |
| 1535 | | } satisfies PermissionResult; |
| 1536 | | }), |
| 1537 | | ); |
| 1538 | | |
| 1539 | | const providerOptions = input.providerOptions?.claudeCode; |
| 1540 | | const permissionMode = |
| 1541 | | toPermissionMode(providerOptions?.permissionMode) ?? |
| 1542 | | (input.runtimeMode === "full-access" ? "bypassPermissions" : undefined); |
| 1543 | | |
| 1544 | | const queryOptions: ClaudeQueryOptions = { |
| 1545 | | ...(input.cwd ? { cwd: input.cwd } : {}), |
| 1546 | | ...(input.model ? { model: input.model } : {}), |
| 1547 | | ...(providerOptions?.binaryPath |
| 1548 | | ? { pathToClaudeCodeExecutable: providerOptions.binaryPath } |
| 1549 | | : {}), |
| 1550 | | ...(permissionMode ? { permissionMode } : {}), |
| 1551 | | ...(permissionMode === "bypassPermissions" |
| 1552 | | ? { allowDangerouslySkipPermissions: true } |
| 1553 | | : {}), |
| 1554 | | ...(providerOptions?.maxThinkingTokens !== undefined |
| 1555 | | ? { maxThinkingTokens: providerOptions.maxThinkingTokens } |
| 1556 | | : {}), |
| 1557 | | ...(resumeState?.resume ? { resume: resumeState.resume } : {}), |
| 1558 | | ...(resumeState?.resumeSessionAt ? { resumeSessionAt: resumeState.resumeSessionAt } : {}), |
| 1559 | | includePartialMessages: true, |
| 1560 | | canUseTool, |
| 1561 | | env: process.env, |
| 1562 | | ...(input.cwd ? { additionalDirectories: [input.cwd] } : {}), |
| 1563 | | }; |
| 1564 | | |
| 1565 | | const queryRuntime = yield* Effect.try({ |
| 1566 | | try: () => |
| 1567 | | createQuery({ |
| 1568 | | prompt, |
| 1569 | | options: queryOptions, |
| 1570 | | }), |
| 1571 | | catch: (cause) => |
| 1572 | | new ProviderAdapterProcessError({ |
| 1573 | | provider: PROVIDER, |
| 1574 | | threadId, |
| 1575 | | detail: toMessage(cause, "Failed to start Claude runtime session."), |
| 1576 | | cause, |
| 1577 | | }), |
| 1578 | | }); |
| 1579 | | |
| 1580 | | const session: ProviderSession = { |
| 1581 | | threadId, |
| 1582 | | provider: PROVIDER, |
| 1583 | | status: "ready", |
| 1584 | | runtimeMode: input.runtimeMode, |
| 1585 | | ...(input.cwd ? { cwd: input.cwd } : {}), |
| 1586 | | ...(input.model ? { model: input.model } : {}), |
| 1587 | | ...(threadId ? { threadId } : {}), |
| 1588 | | resumeCursor: { |
| 1589 | | ...(threadId ? { threadId } : {}), |
| 1590 | | ...(resumeState?.resume ? { resume: resumeState.resume } : {}), |
| 1591 | | ...(resumeState?.resumeSessionAt |
| 1592 | | ? { resumeSessionAt: resumeState.resumeSessionAt } |
| 1593 | | : {}), |
| 1594 | | turnCount: resumeState?.turnCount ?? 0, |
| 1595 | | }, |
| 1596 | | createdAt: startedAt, |
| 1597 | | updatedAt: startedAt, |
| 1598 | | }; |
| 1599 | | |
| 1600 | | const context: ClaudeSessionContext = { |
| 1601 | | session, |
| 1602 | | promptQueue, |
| 1603 | | query: queryRuntime, |
| 1604 | | startedAt, |
| 1605 | | resumeSessionId: resumeState?.resume, |
| 1606 | | pendingApprovals, |
| 1607 | | turns: [], |
| 1608 | | inFlightTools, |
| 1609 | | turnState: undefined, |
| 1610 | | lastAssistantUuid: resumeState?.resumeSessionAt, |
| 1611 | | lastThreadStartedId: undefined, |
| 1612 | | stopped: false, |
| 1613 | | }; |
| 1614 | | yield* Ref.set(contextRef, context); |
| 1615 | | sessions.set(threadId, context); |
| 1616 | | |
| 1617 | | const sessionStartedStamp = yield* makeEventStamp(); |
| 1618 | | yield* offerRuntimeEvent({ |
| 1619 | | type: "session.started", |
| 1620 | | eventId: sessionStartedStamp.eventId, |
| 1621 | | provider: PROVIDER, |
| 1622 | | createdAt: sessionStartedStamp.createdAt, |
| 1623 | | threadId, |
| 1624 | | payload: input.resumeCursor !== undefined ? { resume: input.resumeCursor } : {}, |
| 1625 | | providerRefs: {}, |
| 1626 | | }); |
| 1627 | | |
| 1628 | | const configuredStamp = yield* makeEventStamp(); |
| 1629 | | yield* offerRuntimeEvent({ |
| 1630 | | type: "session.configured", |
| 1631 | | eventId: configuredStamp.eventId, |
| 1632 | | provider: PROVIDER, |
| 1633 | | createdAt: configuredStamp.createdAt, |
| 1634 | | threadId, |
| 1635 | | payload: { |
| 1636 | | config: { |
| 1637 | | ...(input.model ? { model: input.model } : {}), |
| 1638 | | ...(input.cwd ? { cwd: input.cwd } : {}), |
| 1639 | | ...(permissionMode ? { permissionMode } : {}), |
| 1640 | | ...(providerOptions?.maxThinkingTokens !== undefined |
| 1641 | | ? { maxThinkingTokens: providerOptions.maxThinkingTokens } |
| 1642 | | : {}), |
| 1643 | | }, |
| 1644 | | }, |
| 1645 | | providerRefs: {}, |
| 1646 | | }); |
| 1647 | | |
| 1648 | | const readyStamp = yield* makeEventStamp(); |
| 1649 | | yield* offerRuntimeEvent({ |
| 1650 | | type: "session.state.changed", |
| 1651 | | eventId: readyStamp.eventId, |
| 1652 | | provider: PROVIDER, |
| 1653 | | createdAt: readyStamp.createdAt, |
| 1654 | | threadId, |
| 1655 | | payload: { |
| 1656 | | state: "ready", |
| 1657 | | }, |
| 1658 | | providerRefs: {}, |
| 1659 | | }); |
| 1660 | | |
| 1661 | | Effect.runFork(runSdkStream(context)); |
| 1662 | | |
| 1663 | | return { |
| 1664 | | ...session, |
| 1665 | | }; |
| 1666 | | }); |
| 1667 | | |
| 1668 | | const sendTurn: ClaudeCodeAdapterShape["sendTurn"] = (input) => |
| 1669 | | Effect.gen(function* () { |
| 1670 | | const context = yield* requireSession(input.threadId); |
| 1671 | | |
| 1672 | | if (context.turnState) { |
| 1673 | | return yield* new ProviderAdapterValidationError({ |
| 1674 | | provider: PROVIDER, |
| 1675 | | operation: "sendTurn", |
| 1676 | | issue: `Thread '${input.threadId}' already has an active turn '${context.turnState.turnId}'.`, |
| 1677 | | }); |
| 1678 | | } |
| 1679 | | |
| 1680 | | if (input.model) { |
| 1681 | | yield* Effect.tryPromise({ |
| 1682 | | try: () => context.query.setModel(input.model), |
| 1683 | | catch: (cause) => toRequestError(input.threadId, "turn/setModel", cause), |
| 1684 | | }); |
| 1685 | | } |
| 1686 | | |
| 1687 | | const turnId = TurnId.makeUnsafe(yield* Random.nextUUIDv4); |
| 1688 | | const turnState: ClaudeTurnState = { |
| 1689 | | turnId, |
| 1690 | | assistantItemId: yield* Random.nextUUIDv4, |
| 1691 | | startedAt: yield* nowIso, |
| 1692 | | items: [], |
| 1693 | | messageCompleted: false, |
| 1694 | | emittedTextDelta: false, |
| 1695 | | fallbackAssistantText: "", |
| 1696 | | }; |
| 1697 | | |
| 1698 | | const updatedAt = yield* nowIso; |
| 1699 | | context.turnState = turnState; |
| 1700 | | context.session = { |
| 1701 | | ...context.session, |
| 1702 | | status: "running", |
| 1703 | | activeTurnId: turnId, |
| 1704 | | updatedAt, |
| 1705 | | }; |
| 1706 | | |
| 1707 | | const turnStartedStamp = yield* makeEventStamp(); |
| 1708 | | yield* offerRuntimeEvent({ |
| 1709 | | type: "turn.started", |
| 1710 | | eventId: turnStartedStamp.eventId, |
| 1711 | | provider: PROVIDER, |
| 1712 | | createdAt: turnStartedStamp.createdAt, |
| 1713 | | threadId: context.session.threadId, |
| 1714 | | turnId, |
| 1715 | | payload: input.model ? { model: input.model } : {}, |
| 1716 | | providerRefs: { |
| 1717 | | providerTurnId: String(turnId), |
| 1718 | | }, |
| 1719 | | }); |
| 1720 | | |
| 1721 | | const message = buildUserMessage(input); |
| 1722 | | |
| 1723 | | yield* Queue.offer(context.promptQueue, { |
| 1724 | | type: "message", |
| 1725 | | message, |
| 1726 | | }).pipe(Effect.mapError((cause) => toRequestError(input.threadId, "turn/start", cause))); |
| 1727 | | |
| 1728 | | return { |
| 1729 | | threadId: context.session.threadId, |
| 1730 | | turnId, |
| 1731 | | ...(context.session.resumeCursor !== undefined |
| 1732 | | ? { resumeCursor: context.session.resumeCursor } |
| 1733 | | : {}), |
| 1734 | | }; |
| 1735 | | }); |
| 1736 | | |
| 1737 | | const interruptTurn: ClaudeCodeAdapterShape["interruptTurn"] = (threadId, _turnId) => |
| 1738 | | Effect.gen(function* () { |
| 1739 | | const context = yield* requireSession(threadId); |
| 1740 | | yield* Effect.tryPromise({ |
| 1741 | | try: () => context.query.interrupt(), |
| 1742 | | catch: (cause) => toRequestError(threadId, "turn/interrupt", cause), |
| 1743 | | }); |
| 1744 | | }); |
| 1745 | | |
| 1746 | | const readThread: ClaudeCodeAdapterShape["readThread"] = (threadId) => |
| 1747 | | Effect.gen(function* () { |
| 1748 | | const context = yield* requireSession(threadId); |
| 1749 | | return yield* snapshotThread(context); |
| 1750 | | }); |
| 1751 | | |
| 1752 | | const rollbackThread: ClaudeCodeAdapterShape["rollbackThread"] = (threadId, numTurns) => |
| 1753 | | Effect.gen(function* () { |
| 1754 | | const context = yield* requireSession(threadId); |
| 1755 | | const nextLength = Math.max(0, context.turns.length - numTurns); |
| 1756 | | context.turns.splice(nextLength); |
| 1757 | | yield* updateResumeCursor(context); |
| 1758 | | return yield* snapshotThread(context); |
| 1759 | | }); |
| 1760 | | |
| 1761 | | const respondToRequest: ClaudeCodeAdapterShape["respondToRequest"] = ( |
| 1762 | | threadId, |
| 1763 | | requestId, |
| 1764 | | decision, |
| 1765 | | ) => |
| 1766 | | Effect.gen(function* () { |
| 1767 | | const context = yield* requireSession(threadId); |
| 1768 | | const pending = context.pendingApprovals.get(requestId); |
| 1769 | | if (!pending) { |
| 1770 | | return yield* new ProviderAdapterRequestError({ |
| 1771 | | provider: PROVIDER, |
| 1772 | | method: "item/requestApproval/decision", |
| 1773 | | detail: `Unknown pending approval request: ${requestId}`, |
| 1774 | | }); |
| 1775 | | } |
| 1776 | | |
| 1777 | | context.pendingApprovals.delete(requestId); |
| 1778 | | yield* Deferred.succeed(pending.decision, decision); |
| 1779 | | }); |
| 1780 | | |
| 1781 | | const respondToUserInput: ClaudeCodeAdapterShape["respondToUserInput"] = ( |
| 1782 | | threadId, |
| 1783 | | requestId, |
| 1784 | | _answers, |
| 1785 | | ) => |
| 1786 | | Effect.fail( |
| 1787 | | new ProviderAdapterRequestError({ |
| 1788 | | provider: PROVIDER, |
| 1789 | | method: "item/tool/requestUserInput", |
| 1790 | | detail: `Claude Code does not yet support structured user-input responses for thread '${threadId}' and request '${requestId}'.`, |
| 1791 | | }), |
| 1792 | | ); |
| 1793 | | |
| 1794 | | const stopSession: ClaudeCodeAdapterShape["stopSession"] = (threadId) => |
| 1795 | | Effect.gen(function* () { |
| 1796 | | const context = yield* requireSession(threadId); |
| 1797 | | yield* stopSessionInternal(context, { |
| 1798 | | emitExitEvent: true, |
| 1799 | | }); |
| 1800 | | }); |
| 1801 | | |
| 1802 | | const listSessions: ClaudeCodeAdapterShape["listSessions"] = () => |
| 1803 | | Effect.sync(() => Array.from(sessions.values(), ({ session }) => ({ ...session }))); |
| 1804 | | |
| 1805 | | const hasSession: ClaudeCodeAdapterShape["hasSession"] = (threadId) => |
| 1806 | | Effect.sync(() => { |
| 1807 | | const context = sessions.get(threadId); |
| 1808 | | return context !== undefined && !context.stopped; |
| 1809 | | }); |
| 1810 | | |
| 1811 | | const stopAll: ClaudeCodeAdapterShape["stopAll"] = () => |
| 1812 | | Effect.forEach( |
| 1813 | | sessions, |
| 1814 | | ([, context]) => |
| 1815 | | stopSessionInternal(context, { |
| 1816 | | emitExitEvent: true, |
| 1817 | | }), |
| 1818 | | { discard: true }, |
| 1819 | | ); |
| 1820 | | |
| 1821 | | yield* Effect.addFinalizer(() => |
| 1822 | | Effect.forEach( |
| 1823 | | sessions, |
| 1824 | | ([, context]) => |
| 1825 | | stopSessionInternal(context, { |
| 1826 | | emitExitEvent: false, |
| 1827 | | }), |
| 1828 | | { discard: true }, |
| 1829 | | ).pipe(Effect.tap(() => Queue.shutdown(runtimeEventQueue))), |
| 1830 | | ); |
| 1831 | | |
| 1832 | | return { |
| 1833 | | provider: PROVIDER, |
| 1834 | | capabilities: { |
| 1835 | | sessionModelSwitch: "in-session", |
| 1836 | | }, |
| 1837 | | startSession, |
| 1838 | | sendTurn, |
| 1839 | | interruptTurn, |
| 1840 | | readThread, |
| 1841 | | rollbackThread, |
| 1842 | | respondToRequest, |
| 1843 | | respondToUserInput, |
| 1844 | | stopSession, |
| 1845 | | listSessions, |
| 1846 | | hasSession, |
| 1847 | | stopAll, |
| 1848 | | streamEvents: Stream.fromQueue(runtimeEventQueue), |
| 1849 | | } satisfies ClaudeCodeAdapterShape; |
| 1850 | | }); |
| 1851 | | } |
| 1852 | | |
| 1853 | | export const ClaudeCodeAdapterLive = Layer.effect(ClaudeCodeAdapter, makeClaudeCodeAdapter()); |
| 1854 | | |
| 1855 | | export function makeClaudeCodeAdapterLive(options?: ClaudeCodeAdapterLiveOptions) { |
| 1856 | | return Layer.effect(ClaudeCodeAdapter, makeClaudeCodeAdapter(options)); |
| 1857 | | } |
Julius Marminge <julius0216@outlook.com> 2026-03-05 20:00:52-08:00
Julius Marminge <jmarminge@gmail.com> 2026-03-05 23:00:41-08:00