npm - supercompat - Versions diffs - 3.18.1 → 4.0.0 - Mend

supercompat 3.18.1 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/dist/index.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["/Users/domas/Developer/supercorp/supercompat/packages/supercompat/dist/index.cjs","../src/index.ts","../src/supercompat.ts","../src/supercompatFetch/requestHandlers.ts","../src/supercompatFetch/findRequestHandler.ts","../src/supercompatFetch/originalFetch.ts","../src/supercompatFetch/index.ts","../src/lib/azureOpenai/endpointFromBaseUrl.ts","../src/adapters/client/groqClientAdapter/models/get.ts","../src/adapters/client/groqClientAdapter/models/index.ts","../src/adapters/client/groqClientAdapter/completions/post.ts","../src/adapters/client/groqClientAdapter/completions/index.ts","../src/adapters/client/groqClientAdapter/index.ts","../src/adapters/client/openaiClientAdapter/models/get.ts","../src/adapters/client/openaiClientAdapter/models/index.ts","../src/adapters/client/openaiClientAdapter/completions/post.ts","../src/lib/models/isOModel.ts","../src/lib/messages/systemDeveloperMessages.ts","../src/adapters/client/openaiClientAdapter/completions/index.ts","../src/adapters/client/openaiClientAdapter/index.ts","../src/adapters/client/azureOpenaiClientAdapter/index.ts","../src/adapters/client/azureAiProjectClientAdapter/models/get.ts","../src/adapters/client/azureAiProjectClientAdapter/models/index.ts","../src/adapters/client/azureAiProjectClientAdapter/index.ts","../src/adapters/client/mistralClientAdapter/models/get.ts","../src/adapters/client/mistralClientAdapter/models/index.ts","../src/adapters/client/mistralClientAdapter/completions/serializeChunk.ts","../src/adapters/client/mistralClientAdapter/completions/serializeBody.ts","../src/adapters/client/mistralClientAdapter/completions/post.ts","../src/adapters/client/mistralClientAdapter/completions/index.ts","../src/adapters/client/mistralClientAdapter/index.ts","../src/adapters/client/perplexityClientAdapter/models/get.ts","../src/adapters/client/perplexityClientAdapter/models/index.ts","../src/lib/messages/alternatingMessages.ts","../src/adapters/client/perplexityClientAdapter/completions/post.ts","../src/adapters/client/perplexityClientAdapter/completions/index.ts","../src/adapters/client/perplexityClientAdapter/index.ts","../src/adapters/client/anthropicClientAdapter/models/get.ts","../src/adapters/client/anthropicClientAdapter/models/index.ts","../src/adapters/client/anthropicClientAdapter/completions/post.ts","../src/lib/messages/nonEmptyMessages.ts","../src/lib/messages/firstUserMessages.ts","../src/adapters/client/anthropicClientAdapter/completions/serializeTools.ts","../src/adapters/client/anthropicClientAdapter/completions/serializeMessages/serializeMessage.ts","../src/adapters/client/anthropicClientAdapter/completions/serializeMessages/index.ts","../src/adapters/client/anthropicClientAdapter/completions/serializeBetas.ts","../src/adapters/client/anthropicClientAdapter/normalizeComputerToolCallPayload.ts","../src/adapters/client/anthropicClientAdapter/completions/index.ts","../src/adapters/client/anthropicClientAdapter/index.ts","../src/adapters/client/togetherClientAdapter/models/get.ts","../src/adapters/client/togetherClientAdapter/models/index.ts","../src/adapters/client/togetherClientAdapter/completions/post.ts","../src/adapters/client/togetherClientAdapter/completions/index.ts","../src/adapters/client/togetherClientAdapter/index.ts","../src/adapters/client/googleClientAdapter/models/get.ts","../src/adapters/client/googleClientAdapter/models/index.ts","../src/adapters/client/googleClientAdapter/completions/post.ts","../src/adapters/client/googleClientAdapter/normalizeGeminiAction.ts","../src/adapters/client/googleClientAdapter/completions/index.ts","../src/adapters/client/googleClientAdapter/index.ts","../src/adapters/client/humirisClientAdapter/models/get.ts","../src/adapters/client/humirisClientAdapter/models/index.ts","../src/adapters/client/humirisClientAdapter/completions/post.ts","../src/adapters/client/humirisClientAdapter/completions/index.ts","../src/adapters/client/humirisClientAdapter/index.ts","../src/adapters/client/ollamaClientAdapter/models/get.ts","../src/adapters/client/ollamaClientAdapter/models/index.ts","../src/adapters/client/ollamaClientAdapter/completions/post.ts","../src/adapters/client/ollamaClientAdapter/completions/index.ts","../src/adapters/client/ollamaClientAdapter/index.ts","../src/adapters/client/openRouterClientAdapter/models/get.ts","../src/adapters/client/openRouterClientAdapter/models/index.ts","../src/adapters/client/openRouterClientAdapter/completions/normalizeComputerCall.ts","../src/adapters/client/openRouterClientAdapter/completions/computerUseTool.ts","../src/adapters/client/openRouterClientAdapter/completions/post.ts","../src/adapters/client/openRouterClientAdapter/completions/index.ts","../src/adapters/client/openRouterClientAdapter/index.ts","../src/adapters/run/completionsRunAdapter/index.ts","../src/adapters/run/completionsRunAdapter/messages/index.ts","../src/adapters/run/completionsRunAdapter/messages/serializeMessage.ts","../src/lib/messages/messagesRegexp.ts","../src/lib/runs/runsRegexp.ts","../src/lib/runs/runRegexp.ts","../src/lib/runs/submitToolOutputsRegexp.ts","../src/lib/steps/stepsRegexp.ts","../src/adapters/storage/prismaStorageAdapter/threads/post.ts","../src/adapters/storage/prismaStorageAdapter/threads/serializeThread.ts","../src/adapters/storage/prismaStorageAdapter/threads/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/messages/post.ts","../src/adapters/storage/prismaStorageAdapter/threads/messages/serializeMessage.ts","../src/adapters/storage/prismaStorageAdapter/threads/messages/get.ts","../src/adapters/storage/prismaStorageAdapter/threads/messages/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/get.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/serializeRun.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/mapPrismaRun.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/post.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunInProgress.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunFailed.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunCompleted.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunRequiresAction.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/steps/serializeRunStep.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunStepCreated.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunStepDelta.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunStepCompleted.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadMessageCreated.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadMessageDelta.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadMessageCompleted.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/getMessages.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/run/get.ts","../src/adapters/storage/prismaStorageAdapter/threads/run/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/steps/get.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/steps/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/submitToolOutputs/post/updateRun.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/submitToolOutputs/post/index.ts","../src/adapters/storage/prismaStorageAdapter/threads/runs/submitToolOutputs/index.ts","../src/adapters/storage/prismaStorageAdapter/assistants/post.ts","../src/adapters/storage/prismaStorageAdapter/assistants/index.ts","../src/adapters/storage/prismaStorageAdapter/index.ts","../src/adapters/storage/responsesStorageAdapter/threads/serializeThread.ts","../src/adapters/storage/responsesStorageAdapter/threads/post.ts","../src/adapters/storage/responsesStorageAdapter/threads/index.ts","../src/adapters/storage/responsesStorageAdapter/threads/messages/post.ts","../src/lib/items/serializeItemAsMessage.ts","../src/adapters/storage/responsesStorageAdapter/threads/messages/get.ts","../src/lib/items/responseId.ts","../src/adapters/storage/responsesStorageAdapter/threads/messages/index.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/get.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/post.ts","../src/lib/responses/serializeResponseAsRun.ts","../src/lib/responses/saveResponseItemsToConversationMetadata.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/shared.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/index.ts","../src/adapters/storage/responsesStorageAdapter/threads/run/get.ts","../src/adapters/storage/responsesStorageAdapter/threads/run/index.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/steps/get.ts","../src/lib/items/serializeItemAsMessageCreationRunStep.ts","../src/lib/items/serializeItemAsFunctionCallRunStep.ts","../src/lib/items/serializeItemAsImageGenerationRunStep.ts","../src/lib/items/serializeItemAsWebSearchRunStep.ts","../src/lib/items/serializeItemAsMcpListToolsRunStep.ts","../src/lib/items/serializeItemAsMcpCallRunStep.ts","../src/lib/items/serializeItemAsCodeInterpreterCallRunStep.ts","../src/lib/items/serializeItemAsComputerCallRunStep.ts","../src/lib/items/serializeItemAsReasoningRunStep.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/steps/index.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/submitToolOutputs/shared.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/submitToolOutputs/post/index.ts","../src/adapters/storage/responsesStorageAdapter/threads/runs/submitToolOutputs/index.ts","../src/adapters/storage/responsesStorageAdapter/assistants/get.ts","../src/adapters/storage/responsesStorageAdapter/assistants/post.ts","../src/adapters/storage/responsesStorageAdapter/assistants/index.ts","../src/adapters/storage/responsesStorageAdapter/index.ts","../src/lib/responses/responseRegexp.ts","../src/adapters/storage/azureResponsesStorageAdapter/threads/runs/post.ts","../src/adapters/storage/azureResponsesStorageAdapter/threads/runs/index.ts","../src/adapters/storage/azureResponsesStorageAdapter/threads/runs/submitToolOutputs/post/index.ts","../src/adapters/storage/azureResponsesStorageAdapter/threads/runs/submitToolOutputs/index.ts","../src/adapters/storage/azureResponsesStorageAdapter/responses/get.ts","../src/adapters/storage/azureResponsesStorageAdapter/responses/index.ts","../src/adapters/storage/azureResponsesStorageAdapter/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/post.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/messages/post.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/messages/get.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/messages/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/runs/get.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/runs/post.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/runs/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/run/get.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/run/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/runs/steps/get.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/runs/steps/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/runs/submitToolOutputs/post/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/threads/runs/submitToolOutputs/index.ts","../src/adapters/storage/azureAgentsStorageAdapter/assistants/post.ts","../src/adapters/storage/azureAgentsStorageAdapter/assistants/index.ts","../src/lib/files/fileRegexp.ts","../src/lib/files/fileContentRegexp.ts","../src/lib/files/transformAzureFile.ts","../src/adapters/storage/azureAgentsStorageAdapter/files/get.ts","../src/adapters/storage/azureAgentsStorageAdapter/files/content.ts","../src/adapters/storage/azureAgentsStorageAdapter/index.ts","../src/adapters/run/responsesRunAdapter/index.ts","../src/adapters/run/azureAgentsRunAdapter/index.ts"],"names":["__create","Object","create","__defProp","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__getProtoOf","getPrototypeOf","__hasOwnProp","prototype","hasOwnProperty","__export","target","all","name","get","enumerable","__copyProps","to","from","except","desc","key","call","__toESM","mod","isNodeMode","__esModule","value","__toCommonJS","index_exports","anthropicClientAdapter","azureAgentsRunAdapter","azureAgentsStorageAdapter","azureAiProjectClientAdapter","azureOpenaiClientAdapter","azureResponsesStorageAdapter","completionsRunAdapter","googleClientAdapter","groqClientAdapter","humirisClientAdapter","mistralClientAdapter","ollamaClientAdapter","openRouterClientAdapter","openaiClientAdapter","perplexityClientAdapter","prismaStorageAdapter","responsesRunAdapter","responsesStorageAdapter","supercompat","togetherClientAdapter","module","exports","import_openai","require","import_radash","storageRequestHandlers","storage","runAdapter","client","wrappedClient","result","handleRun","partob","originalClient","requestHandlers","assign","findRequestHandler","url","pathname","URL","regex","RegExp","matches","test","originalFetch","args","options","clientHeaders","newOptions","fetch","buildHeaders","method","toLowerCase","bodyHeaders","headers","retryCount","set","apiKey","supercompatFetch","pathHandler","requestHandler","endpointFromBaseUrl","baseURL","replace","type","AzureOpenAI","apiVersion","endpoint","OpenAI","groq","_url","_options","data","error","models","list","Response","JSON","stringify","status","post","body","response","stream","parse","chat","completions","ReadableStream","start","controller","chunk","enqueue","close","openai","isOModel","model","startsWith","systemDeveloperMessages","messages","map","message","role","omitKeys","resultOptions","import_radash2","omit","azureOpenai","azureAiProject","deployment","deployments","push","id","modelName","object","created","Date","now","owned_by","modelPublisher","mistral","serializeDelta","delta","toolCalls","rest","tool_calls","serializeChoice","choice","finishReason","finish_reason","serializeChunk","choices","serializeMessage","tool_call_id","toolCallId","serializeBody","serializedBody","serializedChunk","complete","perplexity","agentSideRoles","alternatingMessages","forEach","index","nextMessage","content","includes","anthropic","nonEmptyContent","nonEmptyMessages","firstUserMessages","firstMessage","serializeTools","tools","tool","function","description","input_schema","parameters","parseArguments","trimmed","trim","text","toolCall","input","arguments","tool_use_id","serializeMessages","serializeBetas","betas","some","length","coordinateKeys","clickButtonMap","left_click","right_click","middle_click","double_click","triple_click","left_mouse_down","left_mouse_up","keyAliasMap","ctrl","control","cmd","command","meta","win","option","alt","shift","enter","return","esc","escape","tab","space","spacebar","backspace","del","delete","pageup","pagedown","up","down","left","right","sanitizeNumber","toCoordinate","Array","isArray","x","y","tuple","maybe","parts","split","Number","filter","isFinite","findCoordinatesInDetails","details","coords","buildDragPath","path","point","coordinate_start","end","coordinate_end","parseKeys","String","Boolean","normalizeKeys","keys","lowerKey","normalizeScroll","scrollX","scroll_x","scrollY","scroll_y","amount","scroll_amount","direction","scroll_direction","normalizeActionString","action","button","repetitions","state","normalized","duration","hold_duration_ms","Math","round","duration_ms","import_radash3","normalizeAction","payload","rawAction","parsedAction","parseJson","parsed","normalizeComputerToolCallPayload","normalizedPayload","pendingSafetyChecksRaw","pending_safety_checks","pendingSafetyChecks","normalizedAction","systemMessages","otherMessages","system","chatMessages","normalizedContent","normalizedData","import_radash4","fork","join","max_tokens","beta","blockIndexToToolUseId","toolUseIdToIndex","toolUseIdArgumentBuffer","computerToolUseIds","normalizedComputerCalls","nextToolCallIndex","getOrCreateIndexForToolUseId","assignBlockToToolUse","markComputerToolUse","getToolUseIdFromBlock","emitNormalizedToolCall","getOrCreateIndexForBlock","toolUseId","buffered","toolCallIndex","chunkIndex","messageDelta","existing","updated","toolName","normalizedToolName","outputPayload","_toolUseId","_type","_id","Map","Set","has","blockIndex","add","block","uid","partial_json","content_block","output","together","google","pager","page","import_cuid2","GEMINI_ACTION_NAMES","isGeminiAction","act","normalizeGeminiKey","lower","scrollFromDirection","normalizeGeminiAction","coordinate_x","coordinate_y","clearBeforeTyping","clear_before_typing","pressEnter","press_enter","actions","rawKeys","k","destX","destination_x","destY","destination_y","stripFunctionPrefix","getUserDefinedFunctionNames","names","t","hasComputerUseTool","systemParts","contents","toolCallIdToName","geminiCallGroups","skipToolResultIds","lastSubActionMap","msg","part","image_url","match","inlineData","mimeType","fileData","fileUri","tc","createId","thoughtSignature","_thoughtSignature","geminiActionName","_geminiAction","geminiCallId","_geminiCallId","subActionIndex","_subActionIndex","subActionTotal","_subActionTotal","geminiOrigArgs","_geminiArgs","cleanArgs","fcName","primaryId","fcPart","functionCall","geminiName","geminiArgs","lastContent","responseName","responseId","gcId","group","imageContent","extractImageFromToolMessage","responseParts","functionResponse","p","systemInstruction","parseDataUri","geminiTools","functionDeclarations","computerUseEnabled","fn","decl","computerUse","environment","excludedPredefinedFunctions","denormalizeCoords","computerTool","find","displayWidth","computer_use_preview","display_width","displayHeight","display_height","denormX","v","denormY","coordinate","start_coordinate","end_coordinate","isComputerUseFunction","userFns","functionCallToToolCallDeltas","fc","startIndex","rawName","denormed","normalizedActions","i","syntheticToolCallResponse","toolCallDelta","encoder","TextEncoder","chunks","import_radash5","encode","pendingSubActions","next","params","candidate","textParts","lastSig","deltas","config","temperature","top_p","topP","maxOutputTokens","generateContentStream","lastThoughtSignature","emitDeltas","candidates","thought","slice","generateContent","humiris","logprobs","ollama","openRouter","openaiModels","m","MODEL_QUIRKS","normalizedCoords","cleanArtifacts","fuzzyFallback","relativeCoords","referenceWidth","referenceHeight","getQuirks","entries","prefix","quirks","cleanTextArtifacts","KNOWN_ACTION_TYPES","splitCoordDigits","numStr","parseInt","cleanGlmAction","typeVal","argValueMatch","inner","cleanedType","actionType","nums","cleanGlmFields","applyArtifactCleanup","extractJson","direct","codeBlockMatch","jsonMatch","fuzzyExtractJson","clickMatch","actionTypeMatch","xMatch","yMatch","afterX","nextNum","textMatch","denormalize","dimension","denormalizeAction","rescaleCoord","displayDim","referenceDim","rescaleRelativeAction","COORD_FIELDS","normalizeStructure","shouldCleanArtifacts","clean","actionObj","denormalizeComputerCallArguments","argumentsText","buildComputerCallFunction","coordDesc","xDesc","yDesc","properties","enum","items","required","transformTools","computerUseConfig","transformed","display_width_px","display_height_px","ARTIFACT_TAGS","sanitizeContent","convertScreenshotToolMessages","resolveApiKey","parseSSE","reader","decoder","buffer","lines","done","line","getReader","TextDecoder","read","decode","pop","releaseLock","rawFetch","request","httpClient","_baseURL","toString","httpReferer","xTitle","Request","provider","transformedTools","readableStream","ok","d","computerCallIndices","argumentBuffers","emittedIndices","passThrough","initialArgs","denormalized","buf","modifiedChunk","flushChunk","json","import_lodash","import_dayjs","validToolCallContentTypes","serializeToolContent","import_radash6","isEveryToolPartValid","every","toolPart","isObject","serializeToolCall","serializeMessageWithContent","serializeContent","metadata","run","messageToolCalls","runStep","runSteps","rs","stepDetails","step_details","rsTc","getMessages","instructions","import_radash7","flat","updatedToolCall","import_radash8","_","cloneDeep","toolCallsData","prevToolCalls","newToolCalls","runStepDelta","onEvent","opts","providerResponse","e","toolCallsRunStep","currentContent","currentToolCalls","functionToolCalls","pendingFunctionToolCalls","requiredToolCalls","event","response_format","isEmpty","console","failed_at","dayjs","unix","last_error","code","cause","completed_at","run_id","created_at","assistant_id","incomplete_at","incomplete_details","attachments","thread_id","annotations","expired_at","cancelled_at","usage","message_creation","message_id","parsedArguments","computerCall","computer_call","required_action","submit_tool_outputs","messagesRegexp","runsRegexp","runRegexp","submitToolOutputsRegexp","stepsRegexp","serializeThread","thread","import_dayjs2","createdAt","tool_resources","prisma","_urlString","metadataRecord","assistantId","initialCreatedAt","messageData","threadData","Error","import_dayjs3","subtract","toDate","assistant","connect","threads","import_dayjs4","threadId","completedAt","incompleteAt","incompleteDetails","runId","import_radash9","messageContentBlocks","import_radash10","item","urlString","limit","order","after","pageSize","messagesPlusOne","import_radash11","fromEntries","searchParams","findMany","where","take","orderBy","skip","cursor","has_more","last_id","last","serializeRun","import_dayjs5","requiredAction","lastError","expires_at","expiresAt","started_at","startedAt","cancelledAt","failedAt","truncation_strategy","max_completion_tokens","max_prompt_tokens","tool_choice","parallel_tool_calls","mapPrismaRun","truncationStrategy","responseFormat","updatedAt","runs","runsPlusOne","import_radash12","at","threadRunInProgress","update","threadRunFailed","threadRunCompleted","threadRunRequiresAction","serializeRunStep","import_dayjs6","expiredAt","threadRunStepCreated","serializedRunStep","threadRunStepDelta","threadRunStepCompleted","threadMessageCreated","serializedMessage","threadMessageDelta","threadMessageCompleted","latestRunStep","findFirst","handlers","handler","log","getTake","last_messages","include","findUnique","import_radash13","modelSlug","additional_instructions","import_dayjs7","runStepsPlusOne","import_radash14","steps","updateRun","onThreadRunStepCompleted","tool_outputs","$transaction","completedRunStep","import_dayjs8","toolOutput","dir","depth","Promise","resolve","submitToolOutputs","import_dayjs9","assistants","conversation","addAnnotations","conversations","contentType","contentArray","contentItem","file_id","image_file","detail","contentBlock","output_format","serializeAttachments","inputFiles","inputFile","serializeMetadata","serializeItemAsMessage","openaiAssistant","import_radash15","contentBlocksFromContent","import_radash16","textItem","contentBlocksFromAttachments","attachment","createResponseItems","getOpenaiAssistant","select","import_dayjs10","itemId","exec","idx","sort","a","b","raw","arr","j","entry","itemIds","sortOrder","itemsWithRunIds","responseMap","timestampedItems","import_radash17","retrieve","mapItemsWithRunIds","fetchResponsesForItems","assignTimestamps","conversationCreatedAt","assignedTimestamp","responseIds","results","allSettled","responses","itemsWithTimestamps","timestamp","fallbackTimestampForIndex","findNextKnownTimestamp","lastAssigned","nextValue","nextKnown","gap","serializeStatus","serializeUsage","prompt_tokens","input_tokens","completion_tokens","output_tokens","total_tokens","findPendingToolCalls","completedCallIds","call_id","serializeToolCalls","serializeResponseAsRun","pendingToolCalls","BUCKET_PREFIX","MAX_BUCKETS","MAX_VALUE_LENGTH","parseBucket","serializeBucket","bucketKey","listBucketIndices","parseAllPairs","indices","pairs","iid","serializeNonBucketEntries","packIntoBuckets","slots","buckets","currentEntries","flush","serialized","candidateEntries","metadataEquals","keysA","keysB","appendItemIdsToConversationMetadata","base","nonBucketEntries","availableSlots","max","preservedNonBucket","changed","existingPairs","incomingPairs","combinedPairs","concat","retainedOldestFirst","rebuilt","saveResponseItemsToConversationMetadata","truncation","textConfig","format","defaultAssistant","shouldSendInstructions","responseBody","normalizedText","nonStreamResponse","import_radash19","import_radash18","import_dayjs11","o","_threadId","serializeItemAsMessageCreationRunStep","import_radash20","import_dayjs12","serializeFunctionCallOutput","functionCallOutput","serializeItemAsFunctionCallRunStep","import_radash21","import_dayjs13","serializeItemAsImageGenerationRunStep","import_dayjs14","background","quality","size","revised_prompt","serializeItemAsWebSearchRunStep","import_dayjs15","serializeItemAsMcpListToolsRunStep","import_dayjs16","server_label","serializeItemAsMcpCallRunStep","import_dayjs17","serializeOutput","logs","serializeOutputs","outputs","serializeItemAsCodeInterpreterCallRunStep","import_dayjs18","code_interpreter","serializeItemAsComputerCallRunStep","import_radash22","import_dayjs19","computerCallOutput","serializeItemAsReasoningRunStep","import_dayjs20","summary","encrypted_content","latestToolCallItem","functionCallOutputItems","computerCallOutputItems","findLast","flatMap","step","import_radash23","isComputerCallOutput","parsedOutput","getToolCallOutputItems","acknowledged_safety_checks","toolCallOutputItems","previousResponse","toolCallItem","responseRegexp","azureAgentId","import_radash25","agent","import_radash24","import_dayjs21","cachedClient","getAIProjectClient","getAzureClient","aiProjectClient","azureClient","getAzureOpenAIClient","getOpenAIClient","wrappedRunAdapter","wrapHandlerMethod","handlerFactory","openaiClient","createWrappedHandlers","methods","additionalArgs","wrapped","openaiThread","agents","import_dayjs22","textContent","openaiMessage","import_dayjs23","c","ann","start_index","end_index","endIndex","file_citation","fileCitation","fileId","quote","file_path","filePath","imageFile","messagesList","import_dayjs24","first_id","azureRun","retries","maxRetries","createOptions","errorMessage","runIdMatch","activeRunId","activeRun","runData","import_radash26","import_dayjs25","setTimeout","pow","openaiRun","import_dayjs26","stepsList","azureSteps","storedOutputs","outputsMap","azureAgentsFunctionOutput","import_dayjs27","codeInterpreter","image","file_search","fileSearch","messageCreation","messageId","convertAzureEventToOpenAI","azureEvent","eventType","import_dayjs28","stepDetailsDelta","toolResources","existingRun","submitResponse","streamRun","events","finalRun","upsert","runId_toolCallId","openaiEvent","floor","fileRegexp","fileContentRegexp","toUnixSeconds","import_dayjs29","isValid","transformAzureFile","file","createdAtUnix","expiresAtUnix","openaiFile","bytes","filename","purpose","statusDetails","status_details","azureFile","files","import_node_stream","headersToRecord","headerName","toJSON","toBody","nodeStream","Readable","toWeb","Buffer","isBuffer","fileContent","nodeResponse","streamable","headerRecord","getContent","asNodeStream","Headers","getDirectOpenaiAssistant","waitUntil","then","cachedOpenaiAssistant","responseCreatedResponse","responseCompletedResponse","mcpCalls","codeInterpreterCalls","mcpCall","serializedRun","item_id","content_index","import_dayjs30","output_index","partial_image_b64","import_radash27","transformAnnotations","transformMessageContentItem","transformMessageDeltaContentItem","import_dayjs31","runResponse","errorRunId","import_radash28"],"mappings":"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","sourcesContent":["\"use strict\";\nvar __create = Object.create;\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __getProtoOf = Object.getPrototypeOf;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n for (var name in all)\n __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n if (from && typeof from === \"object\" \|\| typeof from === \"function\") {\n for (let key of __getOwnPropNames(from))\n if (!__hasOwnProp.call(to, key) && key !== except)\n __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });\n }\n return to;\n};\nvar __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(\n // If the importer is in node compatibility mode or this is not an ESM\n // file that has been converted to a CommonJS file using a Babel-\n // compatible transform (i.e. \"__esModule\" has not been set), then set\n // \"default\" to the CommonJS \"module.exports\" for node compatibility.\n isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, \"default\", { value: mod, enumerable: true }) : target,\n mod\n));\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/index.ts\nvar index_exports = {};\n__export(index_exports, {\n anthropicClientAdapter: () => anthropicClientAdapter,\n azureAgentsRunAdapter: () => azureAgentsRunAdapter,\n azureAgentsStorageAdapter: () => azureAgentsStorageAdapter,\n azureAiProjectClientAdapter: () => azureAiProjectClientAdapter,\n azureOpenaiClientAdapter: () => azureOpenaiClientAdapter,\n azureResponsesStorageAdapter: () => azureResponsesStorageAdapter,\n completionsRunAdapter: () => completionsRunAdapter,\n googleClientAdapter: () => googleClientAdapter,\n groqClientAdapter: () => groqClientAdapter,\n humirisClientAdapter: () => humirisClientAdapter,\n mistralClientAdapter: () => mistralClientAdapter,\n ollamaClientAdapter: () => ollamaClientAdapter,\n openRouterClientAdapter: () => openRouterClientAdapter,\n openaiClientAdapter: () => openaiClientAdapter,\n perplexityClientAdapter: () => perplexityClientAdapter,\n prismaStorageAdapter: () => prismaStorageAdapter,\n responsesRunAdapter: () => responsesRunAdapter,\n responsesStorageAdapter: () => responsesStorageAdapter,\n supercompat: () => supercompat,\n togetherClientAdapter: () => togetherClientAdapter\n});\nmodule.exports = __toCommonJS(index_exports);\n\n// src/supercompat.ts\nvar import_openai = __toESM(require(\"openai\"), 1);\n\n// src/supercompatFetch/requestHandlers.ts\nvar import_radash = require(\"radash\");\nvar storageRequestHandlers = ({\n storage,\n runAdapter,\n client\n}) => {\n if (!storage) return {};\n if (!runAdapter) return {};\n const wrappedClient = supercompat({\n client\n });\n const result = storage({\n runAdapter: {\n ...runAdapter,\n handleRun: (0, import_radash.partob)(runAdapter.handleRun, { client: wrappedClient })\n },\n client: wrappedClient,\n originalClient: client\n });\n return result.requestHandlers;\n};\nvar requestHandlers = ({\n client,\n storage,\n runAdapter\n}) => (0, import_radash.assign)(\n client.requestHandlers,\n storageRequestHandlers({\n storage,\n runAdapter,\n client\n })\n);\n\n// src/supercompatFetch/findRequestHandler.ts\nvar findRequestHandler = ({\n url,\n requestHandlers: requestHandlers2\n}) => {\n const pathname = new URL(url).pathname;\n for (const key in requestHandlers2) {\n const regex = new RegExp(key);\n const matches = regex.test(pathname);\n if (matches) {\n return requestHandlers2[key];\n }\n }\n};\n\n// src/supercompatFetch/originalFetch.ts\nvar originalFetch = async ({\n args,\n client\n}) => {\n if (client.client?.fetch) {\n const [url, options] = args;\n const clientHeaders = await client.client.buildHeaders({\n options: {},\n method: args[1].method.toLowerCase(),\n bodyHeaders: args[1].headers,\n retryCount: 0\n });\n clientHeaders.set(\"Authorization\", `Bearer ${client.client.apiKey}`);\n const newOptions = {\n ...options,\n headers: clientHeaders\n };\n return client.client.fetch(url, newOptions);\n } else {\n return fetch(...args);\n }\n};\n\n// src/supercompatFetch/index.ts\nvar supercompatFetch = ({\n client,\n storage,\n runAdapter\n}) => {\n const requestHandlers2 = requestHandlers({\n client,\n storage,\n runAdapter\n });\n return async (...args) => {\n const [url, options] = args;\n const pathHandler = findRequestHandler({\n url,\n requestHandlers: requestHandlers2\n });\n if (!pathHandler) {\n return originalFetch({\n client,\n args\n });\n }\n const method = options?.method ?? \"\";\n const requestHandler = pathHandler[method.toLowerCase()];\n if (!requestHandler) {\n return originalFetch({\n client,\n args\n });\n }\n return requestHandler(...args);\n };\n};\n\n// src/lib/azureOpenai/endpointFromBaseUrl.ts\nvar endpointFromBaseUrl = ({\n baseURL\n}) => baseURL.replace(/\\/+openai$/, \"\");\n\n// src/supercompat.ts\nvar supercompat = ({\n client,\n storage,\n runAdapter\n}) => {\n if (client.type === \"AZURE_OPENAI\") {\n return new import_openai.AzureOpenAI({\n apiKey: client.client.apiKey,\n apiVersion: client.client.apiVersion,\n endpoint: endpointFromBaseUrl({ baseURL: client.client.baseURL }),\n fetch: supercompatFetch({\n client,\n storage,\n runAdapter\n })\n });\n }\n return new import_openai.default({\n apiKey: \"SUPERCOMPAT_PLACEHOLDER_OPENAI_KEY\",\n fetch: supercompatFetch({\n client,\n storage,\n runAdapter\n })\n });\n};\n\n// src/adapters/client/groqClientAdapter/models/get.ts\nvar get = ({\n groq\n}) => async (_url, _options) => {\n try {\n const data = await groq.models.list();\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/groqClientAdapter/models/index.ts\nvar models = ({\n groq\n}) => ({\n get: get({ groq })\n});\n\n// src/adapters/client/groqClientAdapter/completions/post.ts\nvar post = ({\n groq\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n if (body.stream) {\n const response = await groq.chat.completions.create(body);\n const stream = new ReadableStream({\n async start(controller) {\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await groq.chat.completions.create(body);\n return new Response(JSON.stringify({\n data\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/groqClientAdapter/completions/index.ts\nvar completions = ({\n groq\n}) => ({\n post: post({ groq })\n});\n\n// src/adapters/client/groqClientAdapter/index.ts\nvar groqClientAdapter = ({\n groq\n}) => ({\n client: groq,\n requestHandlers: {\n \"^/v1/models$\": models({ groq }),\n \"^/v1/chat/completions$\": completions({ groq })\n }\n});\n\n// src/adapters/client/openaiClientAdapter/models/get.ts\nvar get2 = ({\n openai\n}) => async (_url, _options) => {\n try {\n const data = await openai.models.list();\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/openaiClientAdapter/models/index.ts\nvar models2 = ({\n openai\n}) => ({\n get: get2({ openai })\n});\n\n// src/adapters/client/openaiClientAdapter/completions/post.ts\nvar import_radash2 = require(\"radash\");\n\n// src/lib/models/isOModel.ts\nvar isOModel = ({ model }) => model.startsWith(\"o1\") \|\| model.startsWith(\"o3\");\n\n// src/lib/messages/systemDeveloperMessages.ts\nvar systemDeveloperMessages = ({\n messages: messages5,\n model\n}) => {\n if (isOModel({ model })) {\n return messages5.map((message) => {\n if (message.role === \"system\") {\n return {\n ...message,\n // TODO: This should be 'developer' but we're using 'user' for now\n // role: 'developer',\n role: \"user\"\n };\n }\n return message;\n });\n }\n return messages5;\n};\n\n// src/adapters/client/openaiClientAdapter/completions/post.ts\nvar omitKeys = ({\n model\n}) => {\n if (isOModel({ model })) {\n return [\"tools\"];\n }\n return [];\n};\nvar post2 = ({\n openai\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n const messages5 = body.messages;\n const resultOptions = {\n ...(0, import_radash2.omit)(body, omitKeys({ model: body.model })),\n messages: systemDeveloperMessages({\n messages: messages5,\n model: body.model\n })\n };\n if (body.stream) {\n const response = await openai.chat.completions.create(resultOptions);\n const stream = new ReadableStream({\n async start(controller) {\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await openai.chat.completions.create(resultOptions);\n return new Response(JSON.stringify({\n data\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/openaiClientAdapter/completions/index.ts\nvar completions2 = ({\n openai\n}) => ({\n post: post2({ openai })\n});\n\n// src/adapters/client/openaiClientAdapter/index.ts\nvar openaiClientAdapter = ({\n openai\n}) => ({\n client: openai,\n requestHandlers: {\n \"^/v1/models$\": models2({ openai }),\n \"^/(?:v1\|/?openai)/chat/completions$\": completions2({ openai })\n }\n});\n\n// src/adapters/client/azureOpenaiClientAdapter/index.ts\nvar azureOpenaiClientAdapter = ({\n azureOpenai\n}) => ({\n type: \"AZURE_OPENAI\",\n client: azureOpenai,\n requestHandlers: {\n \"^/(?:v1\|/?openai)/chat/completions$\": completions2({\n openai: azureOpenai\n })\n }\n});\n\n// src/adapters/client/azureAiProjectClientAdapter/models/get.ts\nvar get3 = ({\n azureAiProject\n}) => async (_url, _options) => {\n try {\n const models14 = [];\n for await (const deployment of azureAiProject.deployments.list()) {\n if (deployment.type === \"ModelDeployment\" && \"modelName\" in deployment && \"modelPublisher\" in deployment) {\n models14.push({\n id: deployment.modelName,\n object: \"model\",\n created: Date.now(),\n owned_by: deployment.modelPublisher\n });\n }\n }\n return new Response(\n JSON.stringify({\n object: \"list\",\n data: models14\n }),\n {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n }\n );\n } catch (error) {\n return new Response(\n JSON.stringify({\n error\n }),\n {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n }\n );\n }\n};\n\n// src/adapters/client/azureAiProjectClientAdapter/models/index.ts\nvar models3 = ({\n azureAiProject\n}) => ({\n get: get3({ azureAiProject })\n});\n\n// src/adapters/client/azureAiProjectClientAdapter/index.ts\nvar azureAiProjectClientAdapter = ({\n azureAiProject\n}) => ({\n type: \"AZURE_AI_PROJECT\",\n client: azureAiProject,\n requestHandlers: {\n \"^/v1/models$\": models3({ azureAiProject })\n }\n});\n\n// src/adapters/client/mistralClientAdapter/models/get.ts\nvar get4 = ({\n mistral\n}) => async (_url, _options) => {\n try {\n const data = await mistral.models.list();\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/mistralClientAdapter/models/index.ts\nvar models4 = ({\n mistral\n}) => ({\n get: get4({ mistral })\n});\n\n// src/adapters/client/mistralClientAdapter/completions/serializeChunk.ts\nvar serializeDelta = ({\n delta: {\n toolCalls,\n ...rest\n }\n}) => ({\n ...rest,\n ...toolCalls ? {\n tool_calls: toolCalls\n } : {}\n});\nvar serializeChoice = ({\n choice: {\n finishReason,\n delta,\n ...rest\n }\n}) => ({\n ...rest,\n finish_reason: finishReason ?? null,\n delta: serializeDelta({ delta })\n});\nvar serializeChunk = ({\n chunk\n}) => ({\n ...chunk.data,\n ...chunk.data.choices ? {\n choices: chunk.data.choices.map((choice) => serializeChoice({ choice }))\n } : {}\n});\n\n// src/adapters/client/mistralClientAdapter/completions/serializeBody.ts\nvar serializeMessage = ({\n message: {\n // @ts-ignore-next-line\n tool_calls,\n // @ts-ignore-next-line\n tool_call_id,\n ...rest\n }\n}) => ({\n ...rest,\n ...tool_call_id ? {\n toolCallId: tool_call_id\n } : {},\n ...tool_calls ? {\n toolCalls: tool_calls\n } : {}\n});\nvar serializeBody = ({\n body\n}) => ({\n ...body,\n messages: body.messages.map((message) => serializeMessage({\n message\n }))\n});\n\n// src/adapters/client/mistralClientAdapter/completions/post.ts\nvar post3 = ({\n mistral\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n const serializedBody = serializeBody({\n body\n });\n if (body.stream) {\n const response = await mistral.chat.stream(serializedBody);\n const stream = new ReadableStream({\n async start(controller) {\n for await (const chunk of response) {\n const serializedChunk = serializeChunk({\n chunk\n });\n controller.enqueue(`data: ${JSON.stringify(serializedChunk)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await mistral.chat.complete(serializedBody);\n return new Response(JSON.stringify({\n data\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/mistralClientAdapter/completions/index.ts\nvar completions3 = ({\n mistral\n}) => ({\n post: post3({ mistral })\n});\n\n// src/adapters/client/mistralClientAdapter/index.ts\nvar mistralClientAdapter = ({\n mistral\n}) => ({\n client: mistral,\n requestHandlers: {\n \"^/v1/models$\": models4({ mistral }),\n \"^/v1/chat/completions$\": completions3({ mistral })\n }\n});\n\n// src/adapters/client/perplexityClientAdapter/models/get.ts\nvar models5 = [\n \"sonar-reasoning-pro\",\n \"sonar-reasoning\",\n \"sonar-pro\",\n \"sonar\",\n \"r1-1776\",\n \"llama-3.1-sonar-small-128k-online\",\n \"llama-3.1-sonar-large-128k-online\",\n \"llama-3.1-sonar-huge-128k-online\"\n];\nvar get5 = ({\n perplexity\n}) => async (_url, _options) => {\n try {\n return new Response(JSON.stringify({\n type: \"list\",\n data: models5.map((model) => ({\n id: model,\n object: \"model\"\n }))\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/perplexityClientAdapter/models/index.ts\nvar models6 = ({\n perplexity\n}) => ({\n get: get5({ perplexity })\n});\n\n// src/lib/messages/alternatingMessages.ts\nvar agentSideRoles = [\"assistant\", \"system\"];\nvar alternatingMessages = ({\n messages: messages5\n}) => {\n const result = [];\n messages5.forEach((message, index) => {\n result.push(message);\n const nextMessage = messages5[index + 1];\n if (!nextMessage) return;\n if (message.role === \"user\" && nextMessage.role === \"user\") {\n result.push({\n role: \"assistant\",\n content: \"-\"\n });\n } else if (agentSideRoles.includes(message.role) && agentSideRoles.includes(nextMessage.role)) {\n result.push({\n role: \"user\",\n content: \"-\"\n });\n }\n });\n return result;\n};\n\n// src/adapters/client/perplexityClientAdapter/completions/post.ts\nvar post4 = ({\n perplexity\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n const messages5 = alternatingMessages({\n messages: body.messages\n });\n if (body.stream) {\n const response = await perplexity.chat.completions.create({\n ...body,\n messages: messages5\n });\n const stream = new ReadableStream({\n async start(controller) {\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await perplexity.chat.completions.create(body);\n return new Response(JSON.stringify({\n data\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/perplexityClientAdapter/completions/index.ts\nvar completions4 = ({\n perplexity\n}) => ({\n post: post4({ perplexity })\n});\n\n// src/adapters/client/perplexityClientAdapter/index.ts\nvar perplexityClientAdapter = ({\n perplexity\n}) => ({\n client: perplexity,\n requestHandlers: {\n \"^/v1/models$\": models6({ perplexity }),\n \"^/v1/chat/completions$\": completions4({ perplexity })\n }\n});\n\n// src/adapters/client/anthropicClientAdapter/models/get.ts\nvar get6 = ({\n anthropic\n}) => async (_url, _options) => {\n try {\n const response = await anthropic.models.list();\n return new Response(JSON.stringify({\n type: \"list\",\n data: response.data.map((model) => ({\n id: model.id,\n object: \"model\"\n }))\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/anthropicClientAdapter/models/index.ts\nvar models7 = ({\n anthropic\n}) => ({\n get: get6({ anthropic })\n});\n\n// src/adapters/client/anthropicClientAdapter/completions/post.ts\nvar import_radash4 = require(\"radash\");\n\n// src/lib/messages/nonEmptyMessages.ts\nvar nonEmptyContent = ({\n message\n}) => {\n if (message.content == null) {\n return \"-\";\n }\n if (typeof message.content === \"string\") {\n if (!/\\S/.test(message.content)) {\n return \"-\";\n }\n }\n return message.content;\n};\nvar nonEmptyMessages = ({\n messages: messages5\n}) => {\n const result = [];\n messages5.forEach((message) => result.push({\n ...message,\n content: nonEmptyContent({ message })\n }));\n return result;\n};\n\n// src/lib/messages/firstUserMessages.ts\nvar firstUserMessages = ({\n messages: messages5\n}) => {\n const firstMessage = messages5[0];\n if (!firstMessage) return messages5;\n if (firstMessage.role !== \"user\") {\n return [\n {\n role: \"user\",\n content: \"-\"\n },\n ...messages5\n ];\n }\n return messages5;\n};\n\n// src/adapters/client/anthropicClientAdapter/completions/serializeTools.ts\nvar serializeTools = ({\n tools\n}) => (tools ?? []).map((tool) => {\n if (tool.type === \"function\") {\n return {\n name: tool.function.name,\n description: tool.function.description,\n input_schema: tool.function.parameters ?? {\n type: \"object\"\n }\n };\n }\n return {\n type: tool.type,\n // @ts-ignore-next-line\n ...tool[tool.type] \|\| {}\n };\n});\n\n// src/adapters/client/anthropicClientAdapter/completions/serializeMessages/serializeMessage.ts\nvar serializeMessage2 = ({\n message\n}) => {\n const parseArguments = (value) => {\n if (typeof value !== \"string\") return {};\n const trimmed = value.trim();\n if (!trimmed) return {};\n try {\n return JSON.parse(trimmed);\n } catch {\n return {};\n }\n };\n if (message.role === \"user\") {\n return {\n role: \"user\",\n content: message.content\n };\n } else if (message.role === \"assistant\") {\n return {\n role: \"assistant\",\n content: [\n {\n type: \"text\",\n text: message.content\n },\n ...(message.tool_calls ?? []).map((toolCall) => ({\n type: \"tool_use\",\n id: toolCall.id,\n // @ts-expect-error todo\n name: toolCall.function.name,\n // @ts-expect-error todo\n input: parseArguments(toolCall.function.arguments)\n }))\n ]\n };\n } else if (message.role === \"tool\") {\n return {\n role: \"user\",\n content: [\n {\n type: \"tool_result\",\n tool_use_id: message.tool_call_id,\n content: message.content\n }\n ]\n };\n }\n};\n\n// src/adapters/client/anthropicClientAdapter/completions/serializeMessages/index.ts\nvar serializeMessages = ({\n messages: messages5\n}) => messages5.map((message) => serializeMessage2({\n message\n}));\n\n// src/adapters/client/anthropicClientAdapter/completions/serializeBetas.ts\nvar serializeBetas = ({\n tools = []\n}) => {\n const betas = [];\n if (tools.some((tool) => tool.type === \"computer_20250124\")) {\n betas.push(\"computer-use-2025-01-24\");\n }\n if (tools.some((tool) => tool.type === \"code_execution_20250825\")) {\n betas.push(\"code-execution-2025-08-25\");\n }\n if (!betas.length) {\n return {};\n }\n return {\n betas\n };\n};\n\n// src/adapters/client/anthropicClientAdapter/normalizeComputerToolCallPayload.ts\nvar import_radash3 = require(\"radash\");\nvar coordinateKeys = [\n \"coordinate\",\n \"coordinates\",\n \"coordinate_start\",\n \"coordinate_end\",\n \"start\",\n \"end\",\n \"from\",\n \"to\",\n \"target\",\n \"point\",\n \"position\",\n \"cursor_position\",\n \"path\"\n];\nvar clickButtonMap = {\n left_click: \"left\",\n right_click: \"right\",\n middle_click: \"wheel\",\n double_click: \"left\",\n triple_click: \"left\",\n left_mouse_down: \"left\",\n left_mouse_up: \"left\"\n};\nvar keyAliasMap = {\n ctrl: \"ctrl\",\n control: \"ctrl\",\n cmd: \"meta\",\n command: \"meta\",\n meta: \"meta\",\n win: \"meta\",\n option: \"alt\",\n alt: \"alt\",\n shift: \"shift\",\n enter: \"enter\",\n return: \"enter\",\n esc: \"escape\",\n escape: \"escape\",\n tab: \"tab\",\n space: \"space\",\n spacebar: \"space\",\n backspace: \"backspace\",\n del: \"delete\",\n delete: \"delete\",\n pageup: \"pageup\",\n pagedown: \"pagedown\",\n up: \"up\",\n down: \"down\",\n left: \"left\",\n right: \"right\"\n};\nvar sanitizeNumber = (value) => typeof value === \"number\" ? value : void 0;\nvar toCoordinate = (value) => {\n if (!value) return void 0;\n if (Array.isArray(value)) {\n if (value.length === 2 && typeof value[0] === \"number\" && typeof value[1] === \"number\") {\n return { x: value[0], y: value[1] };\n }\n if (value.length > 0 && Array.isArray(value[0])) {\n const tuple = value[0];\n if (tuple.length === 2 && typeof tuple[0] === \"number\" && typeof tuple[1] === \"number\") {\n return { x: tuple[0], y: tuple[1] };\n }\n }\n }\n if (typeof value === \"object\") {\n const maybe = value;\n const x = sanitizeNumber(maybe.x);\n const y = sanitizeNumber(maybe.y);\n if (typeof x === \"number\" && typeof y === \"number\") {\n return { x, y };\n }\n }\n if (typeof value === \"string\") {\n const parts = value.split(/[, ]+/).map(Number).filter(Number.isFinite);\n if (parts.length >= 2) {\n return { x: parts[0], y: parts[1] };\n }\n }\n return void 0;\n};\nvar findCoordinatesInDetails = (details) => {\n for (const key of coordinateKeys) {\n const value = details[key];\n const coords = toCoordinate(value);\n if (coords) {\n return coords;\n }\n }\n return void 0;\n};\nvar buildDragPath = (details) => {\n const path = [];\n if (Array.isArray(details.path)) {\n for (const point of details.path) {\n const coords = toCoordinate(point);\n if (coords) {\n path.push(coords);\n }\n }\n }\n if (!path.length) {\n const start = toCoordinate(details.coordinate_start) \|\| toCoordinate(details.start) \|\| toCoordinate(details.from);\n if (start) {\n path.push(start);\n }\n const end = toCoordinate(details.coordinate_end) \|\| toCoordinate(details.end) \|\| toCoordinate(details.to) \|\| toCoordinate(details.target);\n if (end) {\n path.push(end);\n }\n }\n if (!path.length) {\n const coords = findCoordinatesInDetails(details);\n if (coords) {\n path.push(coords);\n }\n }\n if (!path.length) {\n path.push({ x: 0, y: 0 });\n }\n return path;\n};\nvar parseKeys = (input) => {\n if (Array.isArray(input)) {\n return input.map(String).map((key) => key.trim()).filter(Boolean);\n }\n if (typeof input === \"string\") {\n return input.split(/(?:(?<!\\\\)\\+\|\\s+)/).map((key) => key.replace(/\\\\\\+/g, \"+\")).map((key) => key.trim()).filter(Boolean);\n }\n return [];\n};\nvar normalizeKeys = (keys) => {\n return keys.map((key) => {\n const lowerKey = key.toLowerCase();\n return keyAliasMap[lowerKey] ?? lowerKey;\n });\n};\nvar normalizeScroll = (details) => {\n let scrollX = sanitizeNumber(details.scroll_x) ?? 0;\n let scrollY = sanitizeNumber(details.scroll_y) ?? 0;\n const amount = sanitizeNumber(details.scroll_amount) ?? sanitizeNumber(details.amount) ?? 0;\n const direction = typeof details.scroll_direction === \"string\" ? details.scroll_direction.toLowerCase() : typeof details.direction === \"string\" ? details.direction.toLowerCase() : void 0;\n if (!scrollX && !scrollY && direction && amount) {\n switch (direction) {\n case \"up\":\n scrollY = -amount;\n break;\n case \"down\":\n scrollY = amount;\n break;\n case \"left\":\n scrollX = -amount;\n break;\n case \"right\":\n scrollX = amount;\n break;\n default:\n break;\n }\n }\n return { scroll_x: scrollX, scroll_y: scrollY };\n};\nvar normalizeActionString = (action, details) => {\n const coords = findCoordinatesInDetails(details);\n switch (action) {\n case \"screenshot\":\n return { type: \"screenshot\" };\n case \"left_click\":\n case \"right_click\":\n case \"middle_click\": {\n return {\n type: \"click\",\n button: clickButtonMap[action],\n x: coords?.x ?? 0,\n y: coords?.y ?? 0\n };\n }\n case \"double_click\":\n return {\n type: \"double_click\",\n x: coords?.x ?? 0,\n y: coords?.y ?? 0\n };\n case \"triple_click\":\n return {\n type: \"double_click\",\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n repetitions: 3\n };\n case \"left_mouse_down\":\n return {\n type: \"click\",\n button: clickButtonMap[action],\n state: \"down\",\n x: coords?.x ?? 0,\n y: coords?.y ?? 0\n };\n case \"left_mouse_up\":\n return {\n type: \"click\",\n button: clickButtonMap[action],\n state: \"up\",\n x: coords?.x ?? 0,\n y: coords?.y ?? 0\n };\n case \"left_click_drag\": {\n const path = buildDragPath(details).map(({ x, y }) => ({ x, y }));\n return {\n type: \"drag\",\n path\n };\n }\n case \"mouse_move\":\n case \"cursor_position\":\n return {\n type: \"move\",\n x: coords?.x ?? 0,\n y: coords?.y ?? 0\n };\n case \"scroll\": {\n const { scroll_x, scroll_y } = normalizeScroll(details);\n return {\n type: \"scroll\",\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n scroll_x,\n scroll_y,\n ...typeof details.scroll_direction === \"string\" ? { direction: details.scroll_direction } : typeof details.direction === \"string\" ? { direction: details.direction } : {},\n ...typeof details.scroll_amount === \"number\" ? { amount: details.scroll_amount } : typeof details.amount === \"number\" ? { amount: details.amount } : {}\n };\n }\n case \"type\": {\n const text = typeof details.text === \"string\" ? details.text : typeof details.input === \"string\" ? details.input : \"\";\n return {\n type: \"type\",\n text\n };\n }\n case \"key\":\n case \"hold_key\": {\n const keys = normalizeKeys(\n parseKeys(details.text ?? details.keys ?? details.key)\n );\n const normalized = {\n type: \"keypress\",\n keys\n };\n if (action === \"hold_key\") {\n const duration = sanitizeNumber(details.duration);\n if (typeof duration === \"number\") {\n normalized.hold_duration_ms = Math.round(duration * 1e3);\n }\n }\n return normalized;\n }\n case \"wait\": {\n const duration = sanitizeNumber(details.duration);\n return {\n type: \"wait\",\n ...typeof duration === \"number\" ? { duration_ms: Math.round(duration * 1e3) } : {}\n };\n }\n default: {\n return {\n type: action,\n ...coords ? { x: coords.x, y: coords.y } : {},\n ...(0, import_radash3.omit)(details, [\n ...coordinateKeys,\n \"text\",\n \"scroll_direction\",\n \"direction\",\n \"scroll_amount\",\n \"amount\",\n \"scroll_x\",\n \"scroll_y\",\n \"keys\",\n \"duration\"\n ])\n };\n }\n }\n};\nvar normalizeAction = (payload) => {\n if (payload && typeof payload === \"object\") {\n let rawAction = payload.action;\n if (typeof rawAction === \"string\") {\n const parsedAction = parseJson(rawAction);\n if (parsedAction && typeof parsedAction === \"object\") {\n rawAction = parsedAction;\n }\n }\n if (rawAction && typeof rawAction === \"object\" && typeof rawAction.type === \"string\") {\n return rawAction;\n }\n if (typeof rawAction === \"string\") {\n const details = (0, import_radash3.omit)(payload, [\"action\", \"pending_safety_checks\", \"status\"]);\n return normalizeActionString(rawAction, details);\n }\n if (typeof payload.type === \"string\") {\n return payload;\n }\n }\n if (typeof payload === \"string\") {\n const parsed = parseJson(payload);\n if (parsed && typeof parsed === \"object\") {\n return normalizeAction(parsed);\n }\n return { type: payload };\n }\n return {\n type: \"unknown\",\n value: payload\n };\n};\nvar normalizeComputerToolCallPayload = (payload) => {\n let normalizedPayload = payload;\n if (typeof payload === \"string\") {\n const parsed = parseJson(payload);\n if (parsed !== void 0) {\n normalizedPayload = parsed;\n }\n }\n let pendingSafetyChecksRaw = normalizedPayload && typeof normalizedPayload === \"object\" ? normalizedPayload.pending_safety_checks : void 0;\n if (typeof pendingSafetyChecksRaw === \"string\") {\n const parsed = parseJson(pendingSafetyChecksRaw);\n pendingSafetyChecksRaw = Array.isArray(parsed) ? parsed : [];\n }\n const pendingSafetyChecks = Array.isArray(pendingSafetyChecksRaw) ? pendingSafetyChecksRaw : [];\n const normalizedAction = normalizeAction(normalizedPayload);\n const result = {\n action: normalizedAction,\n pending_safety_checks: pendingSafetyChecks\n };\n if (normalizedPayload && typeof normalizedPayload === \"object\" && \"status\" in normalizedPayload) {\n result.status = normalizedPayload.status;\n }\n return result;\n};\nvar parseJson = (value) => {\n try {\n return JSON.parse(value);\n } catch {\n return void 0;\n }\n};\n\n// src/adapters/client/anthropicClientAdapter/completions/post.ts\nvar post5 = ({\n anthropic\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n const messages5 = body.messages;\n const [systemMessages, otherMessages] = (0, import_radash4.fork)(messages5, (message) => message.role === \"system\");\n const system = systemMessages.map((message) => message.content).join(\"\\n\");\n const chatMessages = nonEmptyMessages({\n messages: firstUserMessages({\n messages: alternatingMessages({\n messages: otherMessages\n })\n })\n });\n const resultOptions = {\n ...(0, import_radash4.omit)(body, [\"response_format\"]),\n model: body.model,\n ...serializeBetas({\n tools: body.tools\n }),\n stream: body.stream,\n system,\n messages: serializeMessages({\n messages: chatMessages\n }),\n max_tokens: 4096,\n tools: serializeTools({\n tools: body.tools\n })\n };\n if (resultOptions.stream) {\n const response = await anthropic.beta.messages.create(resultOptions);\n const stream = new ReadableStream({\n async start(controller) {\n const blockIndexToToolUseId = /* @__PURE__ / new Map();\n const toolUseIdToIndex = / @__PURE__ / new Map();\n const toolUseIdArgumentBuffer = / @__PURE__ / new Map();\n const computerToolUseIds = / @__PURE__ / new Set();\n const normalizedComputerCalls = / @__PURE__ / new Set();\n let nextToolCallIndex = 0;\n const parseJson3 = (value) => {\n try {\n return JSON.parse(value);\n } catch {\n return void 0;\n }\n };\n const getOrCreateIndexForToolUseId = (toolUseId) => {\n if (!toolUseId) {\n return 0;\n }\n if (!toolUseIdToIndex.has(toolUseId)) {\n toolUseIdToIndex.set(toolUseId, nextToolCallIndex++);\n }\n return toolUseIdToIndex.get(toolUseId) ?? 0;\n };\n const assignBlockToToolUse = ({\n blockIndex,\n toolUseId\n }) => {\n if (typeof blockIndex === \"number\" && toolUseId) {\n blockIndexToToolUseId.set(blockIndex, toolUseId);\n }\n };\n const markComputerToolUse = (toolUseId) => {\n if (!toolUseId) return;\n computerToolUseIds.add(toolUseId);\n normalizedComputerCalls.delete(toolUseId);\n toolUseIdArgumentBuffer.set(toolUseId, \"\");\n };\n const getToolUseIdFromBlock = (block) => {\n if (!block \|\| typeof block !== \"object\") return void 0;\n if (typeof block.tool_use_id === \"string\") {\n return block.tool_use_id;\n }\n if (typeof block.id === \"string\") {\n return block.id;\n }\n return void 0;\n };\n const emitNormalizedToolCall = ({\n normalized,\n toolCallIndex,\n chunkIndex\n }) => {\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash4.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [\n {\n index: chunkIndex,\n delta: {\n tool_calls: [\n {\n index: toolCallIndex,\n function: {\n arguments: JSON.stringify(normalized)\n }\n }\n ]\n }\n }\n ]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n };\n const getOrCreateIndexForBlock = (blockIndex) => {\n if (typeof blockIndex !== \"number\") {\n return 0;\n }\n const toolUseId = blockIndexToToolUseId.get(blockIndex);\n return getOrCreateIndexForToolUseId(toolUseId);\n };\n for await (const chunk of response) {\n if (chunk.type === \"content_block_stop\") {\n const toolUseId = typeof chunk.index === \"number\" ? blockIndexToToolUseId.get(chunk.index) : void 0;\n if (toolUseId && computerToolUseIds.has(toolUseId) && !normalizedComputerCalls.has(toolUseId)) {\n const buffered = toolUseIdArgumentBuffer.get(toolUseId) ?? \"\";\n const parsed = buffered ? parseJson3(buffered) : void 0;\n if (parsed !== void 0) {\n const normalized = normalizeComputerToolCallPayload(parsed);\n const toolCallIndex = getOrCreateIndexForToolUseId(toolUseId);\n const chunkIndex = typeof chunk.index === \"number\" ? chunk.index : 0;\n emitNormalizedToolCall({\n normalized,\n toolCallIndex,\n chunkIndex\n });\n normalizedComputerCalls.add(toolUseId);\n }\n }\n if (toolUseId && !computerToolUseIds.has(toolUseId)) {\n const buffered = toolUseIdArgumentBuffer.get(toolUseId) ?? \"\";\n if (!buffered.trim()) {\n const toolCallIndex = getOrCreateIndexForToolUseId(toolUseId);\n const chunkIndex = typeof chunk.index === \"number\" ? chunk.index : 0;\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash4.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [\n {\n index: chunkIndex,\n delta: {\n content: null,\n tool_calls: [\n {\n index: toolCallIndex,\n function: {\n arguments: \"{}\"\n }\n }\n ]\n }\n }\n ]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n }\n }\n if (toolUseId) {\n toolUseIdArgumentBuffer.delete(toolUseId);\n computerToolUseIds.delete(toolUseId);\n normalizedComputerCalls.delete(toolUseId);\n }\n if (typeof chunk.index === \"number\") {\n blockIndexToToolUseId.delete(chunk.index);\n }\n continue;\n }\n if (chunk.type === \"content_block_delta\") {\n let delta;\n if (chunk.delta.type === \"input_json_delta\") {\n const toolUseId = typeof chunk.index === \"number\" ? blockIndexToToolUseId.get(chunk.index) : void 0;\n if (toolUseId && computerToolUseIds.has(toolUseId)) {\n const existing = toolUseIdArgumentBuffer.get(toolUseId) ?? \"\";\n const updated = `${existing}${chunk.delta.partial_json ?? \"\"}`;\n toolUseIdArgumentBuffer.set(toolUseId, updated);\n if (!normalizedComputerCalls.has(toolUseId)) {\n const parsed = parseJson3(updated);\n if (parsed !== void 0) {\n const normalized = normalizeComputerToolCallPayload(parsed);\n const toolCallIndex = getOrCreateIndexForToolUseId(toolUseId);\n const chunkIndex = typeof chunk.index === \"number\" ? chunk.index : 0;\n emitNormalizedToolCall({\n normalized,\n toolCallIndex,\n chunkIndex\n });\n normalizedComputerCalls.add(toolUseId);\n }\n }\n continue;\n }\n if (toolUseId) {\n const existing = toolUseIdArgumentBuffer.get(toolUseId) ?? \"\";\n toolUseIdArgumentBuffer.set(\n toolUseId,\n `${existing}${chunk.delta.partial_json ?? \"\"}`\n );\n }\n const index = getOrCreateIndexForBlock(chunk.index);\n delta = {\n tool_calls: [\n {\n index,\n function: {\n arguments: chunk.delta.partial_json\n }\n }\n ]\n };\n } else if (\"text\" in chunk.delta) {\n delta = {\n content: chunk.delta.text\n };\n } else {\n delta = {\n content: \"\"\n };\n }\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash4.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [\n {\n index: chunk.index,\n delta\n }\n ]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n } else if (chunk.type === \"content_block_start\") {\n let delta;\n if (chunk.content_block.type === \"tool_use\") {\n const toolName = chunk.content_block.name;\n const normalizedToolName = toolName === \"computer\" ? \"computer_call\" : toolName;\n const index = getOrCreateIndexForToolUseId(chunk.content_block.id);\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: chunk.content_block.id\n });\n if (normalizedToolName === \"computer_call\") {\n markComputerToolUse(chunk.content_block.id);\n } else if (!toolUseIdArgumentBuffer.has(chunk.content_block.id)) {\n toolUseIdArgumentBuffer.set(chunk.content_block.id, \"\");\n }\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: chunk.content_block.id,\n type: \"function\",\n function: {\n name: normalizedToolName,\n arguments: \"\"\n }\n }\n ]\n };\n } else if (chunk.content_block.type === \"server_tool_use\") {\n const index = getOrCreateIndexForToolUseId(chunk.content_block.id);\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: chunk.content_block.id\n });\n if (!toolUseIdArgumentBuffer.has(chunk.content_block.id)) {\n toolUseIdArgumentBuffer.set(chunk.content_block.id, \"\");\n }\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: chunk.content_block.id,\n type: \"function\",\n function: {\n name: chunk.content_block.name,\n arguments: \"\"\n }\n }\n ]\n };\n } else if (chunk.content_block.type === \"web_search_tool_result\") {\n const outputPayload = {\n content: chunk.content_block.content ?? []\n };\n const toolCallId = getToolUseIdFromBlock(chunk.content_block) ?? \"\";\n const index = getOrCreateIndexForToolUseId(toolCallId);\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: toolCallId\n });\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: toolCallId,\n type: \"function\",\n function: {\n output: JSON.stringify(outputPayload)\n }\n }\n ]\n };\n } else if ([\"code_execution_tool_result\", \"bash_code_execution_tool_result\", \"python_code_execution_tool_result\"].includes(\n chunk.content_block.type\n )) {\n const toolCallId = getToolUseIdFromBlock(chunk.content_block) ?? \"\";\n const {\n tool_use_id: _toolUseId,\n type: _type,\n id: _id,\n ...rest\n } = chunk.content_block;\n const index = getOrCreateIndexForToolUseId(toolCallId);\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: toolCallId\n });\n const outputPayload = Object.keys(rest).length > 0 ? rest : {\n content: chunk.content_block.content ?? {}\n };\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: toolCallId,\n type: \"function\",\n function: {\n output: JSON.stringify(outputPayload)\n }\n }\n ]\n };\n } else if (\"text\" in chunk.content_block) {\n delta = {\n content: chunk.content_block.text\n };\n } else {\n delta = {\n content: \"\"\n };\n }\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash4.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [\n {\n index: chunk.index,\n delta\n }\n ]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n } else if (chunk.type === \"message_start\") {\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash4.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [\n {\n index: 0,\n delta: {\n content: \"\"\n }\n }\n ]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n }\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await anthropic.messages.create(resultOptions);\n const normalizedContent = Array.isArray(data?.content) ? data.content.map((block) => {\n if (block?.type === \"tool_use\" && block?.name === \"computer\") {\n return {\n ...block,\n input: normalizeComputerToolCallPayload(block.input ?? {})\n };\n }\n return block;\n }) : data?.content;\n const normalizedData = {\n ...data,\n ...normalizedContent ? { content: normalizedContent } : {}\n };\n return new Response(JSON.stringify({\n data: normalizedData\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/anthropicClientAdapter/completions/index.ts\nvar completions5 = ({\n anthropic\n}) => ({\n post: post5({ anthropic })\n});\n\n// src/adapters/client/anthropicClientAdapter/index.ts\nvar anthropicClientAdapter = ({\n anthropic\n}) => ({\n client: anthropic,\n requestHandlers: {\n \"^/v1/models$\": models7({ anthropic }),\n \"^/v1/chat/completions$\": completions5({ anthropic })\n }\n});\n\n// src/adapters/client/togetherClientAdapter/models/get.ts\nvar get7 = ({\n together\n}) => async (_url, _options) => {\n try {\n const data = await together.models.list();\n return new Response(JSON.stringify({\n type: \"list\",\n // @ts-ignore-next-line\n data: data.body\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/togetherClientAdapter/models/index.ts\nvar models8 = ({\n together\n}) => ({\n get: get7({ together })\n});\n\n// src/adapters/client/togetherClientAdapter/completions/post.ts\nvar post6 = ({\n together\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n if (body.stream) {\n const response = await together.chat.completions.create(body);\n const stream = new ReadableStream({\n async start(controller) {\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await together.chat.completions.create(body);\n return new Response(JSON.stringify({\n data\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/togetherClientAdapter/completions/index.ts\nvar completions6 = ({\n together\n}) => ({\n post: post6({ together })\n});\n\n// src/adapters/client/togetherClientAdapter/index.ts\nvar togetherClientAdapter = ({\n together\n}) => ({\n client: together,\n requestHandlers: {\n \"^/v1/models$\": models8({ together }),\n \"^/(?:v1\|/?openai)/chat/completions$\": completions6({ together })\n }\n});\n\n// src/adapters/client/googleClientAdapter/models/get.ts\nvar get8 = ({\n google\n}) => async (_url, _options) => {\n try {\n const pager = await google.models.list();\n return new Response(JSON.stringify({\n type: \"list\",\n data: pager.page.map((model) => ({\n id: model.name ?? \"\",\n object: \"model\"\n }))\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/googleClientAdapter/models/index.ts\nvar models9 = ({\n google\n}) => ({\n get: get8({ google })\n});\n\n// src/adapters/client/googleClientAdapter/completions/post.ts\nvar import_cuid2 = require(\"@paralleldrive/cuid2\");\nvar import_radash5 = require(\"radash\");\n\n// src/adapters/client/googleClientAdapter/normalizeGeminiAction.ts\nvar GEMINI_ACTION_NAMES = / @__PURE__ / new Set([\n \"click_at\",\n \"single_click_at\",\n \"right_click_at\",\n \"double_click_at\",\n \"triple_click_at\",\n \"hover_at\",\n \"type_text_at\",\n \"key_combination\",\n \"scroll_at\",\n \"scroll_document\",\n \"drag_and_drop\",\n \"wait_5_seconds\",\n \"wait_for_load\"\n]);\nvar isGeminiAction = (name) => GEMINI_ACTION_NAMES.has(name);\nvar act = (action) => ({\n action,\n pending_safety_checks: []\n});\nvar normalizeGeminiKey = (key) => {\n const lower = key.toLowerCase();\n switch (lower) {\n case \"control\":\n return \"ctrl\";\n case \"command\":\n case \"cmd\":\n return \"meta\";\n case \"option\":\n return \"alt\";\n default:\n return lower;\n }\n};\nvar scrollFromDirection = (direction, amount) => {\n if (!direction) return { scroll_x: 0, scroll_y: 0 };\n switch (direction.toLowerCase()) {\n case \"up\":\n return { scroll_x: 0, scroll_y: -amount };\n case \"down\":\n return { scroll_x: 0, scroll_y: amount };\n case \"left\":\n return { scroll_x: -amount, scroll_y: 0 };\n case \"right\":\n return { scroll_x: amount, scroll_y: 0 };\n default:\n return { scroll_x: 0, scroll_y: 0 };\n }\n};\nvar normalizeGeminiAction = (name, args) => {\n const x = typeof args.x === \"number\" ? args.x : typeof args.coordinate_x === \"number\" ? args.coordinate_x : 0;\n const y = typeof args.y === \"number\" ? args.y : typeof args.coordinate_y === \"number\" ? args.coordinate_y : 0;\n switch (name) {\n case \"click_at\":\n case \"single_click_at\":\n return [act({ type: \"click\", button: \"left\", x, y })];\n case \"right_click_at\":\n return [act({ type: \"click\", button: \"right\", x, y })];\n case \"double_click_at\":\n return [act({ type: \"double_click\", x, y })];\n case \"triple_click_at\":\n return [act({ type: \"double_click\", x, y, repetitions: 3 })];\n case \"hover_at\":\n return [act({ type: \"move\", x, y })];\n case \"type_text_at\": {\n const text = typeof args.text === \"string\" ? args.text : \"\";\n const clearBeforeTyping = args.clear_before_typing !== false;\n const pressEnter = args.press_enter !== false;\n const actions = [\n act({ type: \"click\", button: \"left\", x, y })\n ];\n if (clearBeforeTyping) {\n actions.push(act({ type: \"keypress\", keys: [\"ctrl\", \"a\"] }));\n actions.push(act({ type: \"keypress\", keys: [\"Backspace\"] }));\n }\n actions.push(act({ type: \"type\", text }));\n if (pressEnter) {\n actions.push(act({ type: \"keypress\", keys: [\"Return\"] }));\n }\n return actions;\n }\n case \"key_combination\": {\n const rawKeys = args.keys;\n let keys;\n if (Array.isArray(rawKeys)) {\n keys = rawKeys.map(String).map(normalizeGeminiKey);\n } else if (typeof rawKeys === \"string\") {\n keys = rawKeys.split(/[+\\s]+/).map((k) => k.trim()).filter(Boolean).map(normalizeGeminiKey);\n } else {\n keys = [];\n }\n return [act({ type: \"keypress\", keys })];\n }\n case \"scroll_at\": {\n const direction = typeof args.direction === \"string\" ? args.direction : void 0;\n const amount = typeof args.amount === \"number\" ? args.amount : 3;\n const { scroll_x, scroll_y } = scrollFromDirection(direction, amount);\n return [act({ type: \"scroll\", x, y, scroll_x, scroll_y })];\n }\n case \"scroll_document\": {\n const direction = typeof args.direction === \"string\" ? args.direction : void 0;\n const amount = typeof args.amount === \"number\" ? args.amount : 3;\n const { scroll_x, scroll_y } = scrollFromDirection(direction, amount);\n return [act({ type: \"scroll\", x: 640, y: 360, scroll_x, scroll_y })];\n }\n case \"drag_and_drop\": {\n const destX = typeof args.destination_x === \"number\" ? args.destination_x : 0;\n const destY = typeof args.destination_y === \"number\" ? args.destination_y : 0;\n return [act({ type: \"drag\", path: [{ x, y }, { x: destX, y: destY }] })];\n }\n case \"wait_5_seconds\":\n case \"wait_for_load\":\n return [act({ type: \"wait\" })];\n // navigate, go_back, go_forward, open_web_browser, search are excluded\n // via excludedPredefinedFunctions in the tool config\n default:\n return [act({ type: name, ...args })];\n }\n};\n\n// src/adapters/client/googleClientAdapter/completions/post.ts\nvar stripFunctionPrefix = (name) => name.replace(/^default_api:/, \"\");\nvar getUserDefinedFunctionNames = (tools) => {\n const names = / @__PURE__ / new Set();\n if (!tools) return names;\n for (const t of tools) {\n if (t.type === \"function\" && t.function?.name) {\n names.add(t.function.name);\n }\n }\n return names;\n};\nvar hasComputerUseTool = (tools) => !!tools?.some((t) => t.type === \"computer_use_preview\");\nvar serializeMessages2 = (messages5) => {\n const systemParts = [];\n const contents = [];\n const toolCallIdToName = / @__PURE__ / new Map();\n const geminiCallGroups = / @__PURE__ / new Map();\n const skipToolResultIds = / @__PURE__ / new Set();\n const lastSubActionMap = / @__PURE__ / new Map();\n for (const msg of messages5) {\n if (msg.role === \"system\" \|\| msg.role === \"developer\") {\n systemParts.push(typeof msg.content === \"string\" ? msg.content : JSON.stringify(msg.content));\n continue;\n }\n if (msg.role === \"user\") {\n const parts = [];\n if (typeof msg.content === \"string\") {\n parts.push({ text: msg.content });\n } else if (Array.isArray(msg.content)) {\n for (const part of msg.content) {\n if (part.type === \"text\") {\n parts.push({ text: part.text });\n } else if (part.type === \"image_url\") {\n const url = typeof part.image_url === \"string\" ? part.image_url : part.image_url?.url;\n if (url?.startsWith(\"data:\")) {\n const match = url.match(/^data:([^;]+);base64,(.+)$/);\n if (match) {\n parts.push({ inlineData: { mimeType: match[1], data: match[2] } });\n }\n } else if (url) {\n parts.push({ fileData: { fileUri: url, mimeType: \"image/png\" } });\n }\n }\n }\n }\n if (parts.length > 0) {\n contents.push({ role: \"user\", parts });\n }\n continue;\n }\n if (msg.role === \"assistant\") {\n const parts = [];\n if (msg.content) {\n const text = typeof msg.content === \"string\" ? msg.content : \"\";\n if (text) {\n parts.push({ text });\n }\n }\n if (msg.tool_calls) {\n for (const tc of msg.tool_calls) {\n const name = tc.function?.name ?? \"\";\n const id = tc.id ?? `call_${(0, import_cuid2.createId)()}`;\n let args = {};\n try {\n args = JSON.parse(tc.function?.arguments ?? \"{}\");\n } catch {\n }\n const thoughtSignature = args._thoughtSignature;\n const geminiActionName = args._geminiAction;\n const geminiCallId = args._geminiCallId;\n const subActionIndex = args._subActionIndex;\n const subActionTotal = args._subActionTotal;\n const geminiOrigArgs = args._geminiArgs;\n const cleanArgs = { ...args };\n delete cleanArgs._thoughtSignature;\n delete cleanArgs._geminiAction;\n delete cleanArgs._geminiCallId;\n delete cleanArgs._subActionIndex;\n delete cleanArgs._subActionTotal;\n delete cleanArgs._geminiArgs;\n if (geminiCallId && typeof subActionIndex === \"number\" && typeof subActionTotal === \"number\") {\n if (subActionIndex === 0) {\n const fcName = geminiActionName ?? name;\n geminiCallGroups.set(geminiCallId, { name: fcName, primaryId: id });\n toolCallIdToName.set(id, fcName);\n if (subActionTotal > 1) skipToolResultIds.add(id);\n const fcPart2 = { functionCall: { name: fcName, args: geminiOrigArgs ?? {}, id } };\n if (thoughtSignature) fcPart2.thoughtSignature = thoughtSignature;\n parts.push(fcPart2);\n } else if (subActionIndex === subActionTotal - 1) {\n lastSubActionMap.set(id, geminiCallId);\n } else {\n skipToolResultIds.add(id);\n }\n continue;\n }\n let geminiName = name;\n if (name === \"computer_call\" && args.action && typeof args.action === \"object\") {\n geminiName = geminiActionName ?? args.action.type ?? name;\n }\n let geminiArgs;\n if (name === \"computer_call\" && cleanArgs.action && typeof cleanArgs.action === \"object\") {\n const action = cleanArgs.action;\n const { type: _type, ...rest } = action;\n geminiArgs = rest;\n } else {\n geminiArgs = cleanArgs;\n }\n toolCallIdToName.set(id, geminiName);\n const fcPart = { functionCall: { name: geminiName, args: geminiArgs, id } };\n if (thoughtSignature) {\n fcPart.thoughtSignature = thoughtSignature;\n }\n parts.push(fcPart);\n }\n }\n if (parts.length > 0) {\n contents.push({ role: \"model\", parts });\n }\n continue;\n }\n if (msg.role === \"tool\") {\n const toolCallId = msg.tool_call_id ?? \"\";\n if (skipToolResultIds.has(toolCallId)) continue;\n let responseName;\n let responseId2;\n if (lastSubActionMap.has(toolCallId)) {\n const gcId = lastSubActionMap.get(toolCallId);\n const group = geminiCallGroups.get(gcId);\n responseName = group.name;\n responseId2 = group.primaryId;\n } else {\n responseName = toolCallIdToName.get(toolCallId) ?? \"\";\n responseId2 = toolCallId;\n }\n const parts = [];\n const imageContent = extractImageFromToolMessage(msg);\n if (imageContent) {\n const responseParts = [{\n inlineData: {\n mimeType: imageContent.mimeType,\n data: imageContent.data\n }\n }];\n parts.push({\n functionResponse: {\n id: responseId2,\n name: responseName,\n response: { output: \"Screenshot captured.\" },\n parts: responseParts\n }\n });\n } else {\n const output = typeof msg.content === \"string\" ? msg.content : JSON.stringify(msg.content);\n parts.push({\n functionResponse: {\n id: responseId2,\n name: responseName,\n response: { output }\n }\n });\n }\n const lastContent = contents[contents.length - 1];\n if (lastContent && lastContent.role === \"user\" && lastContent.parts?.some((p) => p.functionResponse)) {\n lastContent.parts.push(...parts);\n } else {\n contents.push({ role: \"user\", parts });\n }\n continue;\n }\n }\n return {\n contents,\n ...systemParts.length > 0 ? { systemInstruction: systemParts.join(\"\\n\") } : {}\n };\n};\nvar extractImageFromToolMessage = (msg) => {\n const content = msg.content;\n if (Array.isArray(content)) {\n for (const part of content) {\n if (part.type === \"image_url\") {\n const url = typeof part.image_url === \"string\" ? part.image_url : part.image_url?.url;\n return parseDataUri(url);\n }\n }\n return null;\n }\n if (typeof content === \"string\") {\n try {\n const parsed = JSON.parse(content);\n if (parsed.type === \"computer_screenshot\" && parsed.image_url) {\n return parseDataUri(parsed.image_url);\n }\n } catch {\n }\n }\n return null;\n};\nvar parseDataUri = (url) => {\n if (!url) return null;\n const match = url.match(/^data:([^;]+);base64,(.+)$/);\n if (!match) return null;\n return { mimeType: match[1], data: match[2] };\n};\nvar serializeTools2 = (tools) => {\n if (!tools \|\| tools.length === 0) return [];\n const geminiTools = [];\n const functionDeclarations = [];\n let computerUseEnabled = false;\n for (const tool of tools) {\n if (tool.type === \"computer_use_preview\") {\n computerUseEnabled = true;\n continue;\n }\n if (tool.type === \"function\") {\n const fn = tool.function;\n if (!fn) continue;\n const decl = {\n name: fn.name\n };\n if (fn.description) {\n decl.description = fn.description;\n }\n if (fn.parameters) {\n decl.parameters = fn.parameters;\n }\n functionDeclarations.push(decl);\n }\n }\n if (computerUseEnabled) {\n geminiTools.push({\n computerUse: {\n environment: \"ENVIRONMENT_BROWSER\",\n excludedPredefinedFunctions: [\n \"navigate\",\n \"go_back\",\n \"go_forward\",\n \"search\",\n \"open_web_browser\"\n ]\n }\n });\n }\n if (functionDeclarations.length > 0) {\n geminiTools.push({ functionDeclarations });\n }\n return geminiTools;\n};\nvar denormalizeCoords = (args, tools) => {\n const computerTool = tools?.find((t) => t.type === \"computer_use_preview\");\n if (!computerTool) return args;\n const displayWidth = computerTool.computer_use_preview?.display_width ?? 1280;\n const displayHeight = computerTool.computer_use_preview?.display_height ?? 720;\n const result = { ...args };\n const denormX = (v) => Math.round(v / 1e3 displayWidth);\n const denormY = (v) => Math.round(v / 1e3 * displayHeight);\n if (typeof result.x === \"number\") result.x = denormX(result.x);\n if (typeof result.y === \"number\") result.y = denormY(result.y);\n if (typeof result.coordinate_x === \"number\") result.coordinate_x = denormX(result.coordinate_x);\n if (typeof result.coordinate_y === \"number\") result.coordinate_y = denormY(result.coordinate_y);\n if (Array.isArray(result.coordinate) && result.coordinate.length === 2) {\n result.coordinate = [denormX(result.coordinate[0]), denormY(result.coordinate[1])];\n }\n if (Array.isArray(result.start_coordinate) && result.start_coordinate.length === 2) {\n result.start_coordinate = [denormX(result.start_coordinate[0]), denormY(result.start_coordinate[1])];\n }\n if (Array.isArray(result.end_coordinate) && result.end_coordinate.length === 2) {\n result.end_coordinate = [denormX(result.end_coordinate[0]), denormY(result.end_coordinate[1])];\n }\n if (typeof result.destination_x === \"number\") result.destination_x = denormX(result.destination_x);\n if (typeof result.destination_y === \"number\") result.destination_y = denormY(result.destination_y);\n return result;\n};\nvar isComputerUseFunction = (name, tools) => {\n if (!hasComputerUseTool(tools)) return false;\n const userFns = getUserDefinedFunctionNames(tools);\n return !userFns.has(name);\n};\nvar functionCallToToolCallDeltas = (fc, startIndex, tools, thoughtSignature) => {\n const rawName = fc.name ?? \"\";\n const name = stripFunctionPrefix(rawName);\n if (isComputerUseFunction(name, tools)) {\n const denormed = denormalizeCoords(fc.args ?? {}, tools);\n if (isGeminiAction(name)) {\n const normalizedActions = normalizeGeminiAction(name, denormed);\n if (normalizedActions.length === 1) {\n const payload2 = { ...normalizedActions[0] };\n payload2._geminiAction = name;\n if (thoughtSignature) payload2._thoughtSignature = thoughtSignature;\n return [{\n index: startIndex,\n id: fc.id ?? `call_${(0, import_cuid2.createId)()}`,\n type: \"function\",\n function: {\n name: \"computer_call\",\n arguments: JSON.stringify(payload2)\n }\n }];\n }\n const geminiCallId = `gcall_${(0, import_cuid2.createId)()}`;\n return normalizedActions.map((normalized2, i) => {\n const payload2 = { ...normalized2 };\n payload2._geminiCallId = geminiCallId;\n payload2._geminiAction = name;\n payload2._subActionIndex = i;\n payload2._subActionTotal = normalizedActions.length;\n if (i === 0) {\n payload2._geminiArgs = denormed;\n if (thoughtSignature) payload2._thoughtSignature = thoughtSignature;\n }\n return {\n index: startIndex + i,\n id: i === 0 ? fc.id ?? `call_${(0, import_cuid2.createId)()}` : `call_${(0, import_cuid2.createId)()}`,\n type: \"function\",\n function: {\n name: \"computer_call\",\n arguments: JSON.stringify(payload2)\n }\n };\n });\n }\n const normalized = normalizeComputerToolCallPayload({ ...denormed, type: name });\n const payload = { ...normalized };\n if (thoughtSignature) payload._thoughtSignature = thoughtSignature;\n return [{\n index: startIndex,\n id: fc.id ?? `call_${(0, import_cuid2.createId)()}`,\n type: \"function\",\n function: {\n name: \"computer_call\",\n arguments: JSON.stringify(payload)\n }\n }];\n }\n const args = fc.args ?? {};\n if (thoughtSignature) {\n args._thoughtSignature = thoughtSignature;\n }\n return [{\n index: startIndex,\n id: fc.id ?? `call_${(0, import_cuid2.createId)()}`,\n type: \"function\",\n function: {\n name,\n arguments: JSON.stringify(args)\n }\n }];\n};\nvar syntheticToolCallResponse = (toolCallDelta, stream) => {\n const delta = { ...toolCallDelta, index: 0 };\n const encoder = new TextEncoder();\n if (stream) {\n const chunks = [\n `data: ${JSON.stringify({\n id: `chatcmpl-${(0, import_radash5.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [{\n index: 0,\n delta: { content: null, tool_calls: [delta] }\n }]\n })}\n\n`,\n `data: ${JSON.stringify({\n id: `chatcmpl-${(0, import_radash5.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [{\n index: 0,\n delta: {},\n finish_reason: \"stop\"\n }]\n })}\n\n`\n ];\n return new Response(\n new ReadableStream({\n start(controller) {\n for (const chunk of chunks) controller.enqueue(encoder.encode(chunk));\n controller.close();\n }\n }),\n { headers: { \"Content-Type\": \"text/event-stream\" } }\n );\n }\n return new Response(JSON.stringify({\n data: {\n id: `chatcmpl-${(0, import_radash5.uid)(29)}`,\n object: \"chat.completion\",\n choices: [{\n index: 0,\n message: {\n role: \"assistant\",\n content: null,\n tool_calls: [delta]\n },\n finish_reason: \"stop\"\n }]\n }\n }), {\n status: 200,\n headers: { \"Content-Type\": \"application/json\" }\n });\n};\nvar post7 = ({\n google\n}) => {\n let pendingSubActions = [];\n return async (_url, options) => {\n const body = JSON.parse(options.body);\n if (pendingSubActions.length > 0) {\n const next = pendingSubActions.shift();\n return syntheticToolCallResponse(next, !!body.stream);\n }\n const messages5 = nonEmptyMessages({ messages: body.messages });\n const { contents, systemInstruction } = serializeMessages2(messages5);\n const geminiTools = serializeTools2(body.tools);\n const params = {\n model: body.model,\n contents,\n config: {\n ...systemInstruction ? { systemInstruction } : {},\n ...geminiTools.length > 0 ? { tools: geminiTools } : {},\n ...typeof body.temperature === \"number\" ? { temperature: body.temperature } : {},\n ...typeof body.top_p === \"number\" ? { topP: body.top_p } : {},\n ...typeof body.max_tokens === \"number\" ? { maxOutputTokens: body.max_tokens } : {}\n }\n };\n if (body.stream) {\n const response = await google.models.generateContentStream(params);\n const stream = new ReadableStream({\n async start(controller) {\n let chunkIndex = 0;\n let lastThoughtSignature;\n for await (const chunk of response) {\n const candidate = chunk.candidates?.[0];\n if (!candidate?.content?.parts) continue;\n for (const part of candidate.content.parts) {\n if (part.thoughtSignature) {\n lastThoughtSignature = part.thoughtSignature;\n }\n if (part.thought && !part.functionCall) continue;\n if (part.text !== void 0 && part.text !== null && !part.thought) {\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash5.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [{\n index: 0,\n delta: { content: part.text }\n }]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n }\n if (part.functionCall) {\n const deltas = functionCallToToolCallDeltas(\n part.functionCall,\n chunkIndex,\n body.tools,\n lastThoughtSignature\n );\n const emitDeltas = deltas.length > 1 ? [deltas[0]] : deltas;\n if (deltas.length > 1) {\n pendingSubActions.push(...deltas.slice(1));\n }\n for (const toolCallDelta of emitDeltas) {\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash5.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [{\n index: 0,\n delta: {\n content: null,\n tool_calls: [toolCallDelta]\n }\n }]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n }\n chunkIndex += emitDeltas.length;\n lastThoughtSignature = void 0;\n }\n }\n if (candidate.finishReason) {\n const messageDelta = {\n id: `chatcmpl-${(0, import_radash5.uid)(29)}`,\n object: \"chat.completion.chunk\",\n choices: [{\n index: 0,\n delta: {},\n finish_reason: \"stop\"\n }]\n };\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\n\n`);\n }\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await google.models.generateContent(params);\n const candidate = data.candidates?.[0];\n const parts = candidate?.content?.parts ?? [];\n const textParts = parts.filter((p) => p.text && !p.thought).map((p) => p.text).join(\"\");\n let lastSig;\n const toolCalls = [];\n for (const p of parts) {\n if (p.thoughtSignature) {\n lastSig = p.thoughtSignature;\n }\n if (p.functionCall) {\n const deltas = functionCallToToolCallDeltas(\n p.functionCall,\n toolCalls.length,\n body.tools,\n lastSig\n );\n if (deltas.length > 1) {\n toolCalls.push(deltas[0]);\n pendingSubActions.push(...deltas.slice(1));\n } else {\n toolCalls.push(...deltas);\n }\n lastSig = void 0;\n }\n }\n const message = {\n role: \"assistant\",\n content: textParts \|\| null\n };\n if (toolCalls.length > 0) {\n message.tool_calls = toolCalls;\n }\n const result = {\n id: `chatcmpl-${(0, import_radash5.uid)(29)}`,\n object: \"chat.completion\",\n choices: [{\n index: 0,\n message,\n finish_reason: \"stop\"\n }]\n };\n return new Response(JSON.stringify({\n data: result\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n };\n};\n\n// src/adapters/client/googleClientAdapter/completions/index.ts\nvar completions7 = ({\n google\n}) => ({\n post: post7({ google })\n});\n\n// src/adapters/client/googleClientAdapter/index.ts\nvar googleClientAdapter = ({\n google\n}) => ({\n client: google,\n requestHandlers: {\n \"^/v1/models$\": models9({ google }),\n \"^/(?:v1\|/?openai)/chat/completions$\": completions7({ google })\n }\n});\n\n// src/adapters/client/humirisClientAdapter/models/get.ts\nvar models10 = [\n \"Humiris/humiris-moai\"\n];\nvar get9 = ({\n humiris\n}) => async (_url, _options) => {\n try {\n return new Response(JSON.stringify({\n type: \"list\",\n data: models10.map((model) => ({\n id: model,\n object: \"model\"\n }))\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/humirisClientAdapter/models/index.ts\nvar models11 = ({\n humiris\n}) => ({\n get: get9({ humiris })\n});\n\n// src/adapters/client/humirisClientAdapter/completions/post.ts\nvar post8 = ({\n humiris\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n if (body.stream) {\n const data = await humiris.chat.completions.create({\n ...body,\n stream: false\n });\n const stream = new ReadableStream({\n async start(controller) {\n const chunk = {\n id: data.id,\n object: \"chat.completion.chunk\",\n created: data.created,\n model: data.created,\n choices: [\n {\n index: 0,\n delta: {\n role: data.choices[0].message.role,\n content: data.choices[0].message.content\n },\n logprobs: null,\n finish_reason: data.choices[0].finish_reason\n }\n ]\n };\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await humiris.chat.completions.create(body);\n return new Response(JSON.stringify({\n data\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/humirisClientAdapter/completions/index.ts\nvar completions8 = ({\n humiris\n}) => ({\n post: post8({ humiris })\n});\n\n// src/adapters/client/humirisClientAdapter/index.ts\nvar humirisClientAdapter = ({\n humiris\n}) => ({\n client: humiris,\n requestHandlers: {\n \"^/v1/models$\": models11({ humiris }),\n \"^/(?:v1\|/?openai)/chat/completions$\": completions8({ humiris })\n }\n});\n\n// src/adapters/client/ollamaClientAdapter/models/get.ts\nvar get10 = ({\n ollama\n}) => async (_url, _options) => {\n try {\n const data = await ollama.models.list();\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/ollamaClientAdapter/models/index.ts\nvar models12 = ({\n ollama\n}) => ({\n get: get10({ ollama })\n});\n\n// src/adapters/client/ollamaClientAdapter/completions/post.ts\nvar post9 = ({\n ollama\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n if (body.stream) {\n const response = await ollama.chat.completions.create(body);\n const stream = new ReadableStream({\n async start(controller) {\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(stream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n try {\n const data = await ollama.chat.completions.create(body);\n return new Response(JSON.stringify({\n data\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n }\n};\n\n// src/adapters/client/ollamaClientAdapter/completions/index.ts\nvar completions9 = ({\n ollama\n}) => ({\n post: post9({ ollama })\n});\n\n// src/adapters/client/ollamaClientAdapter/index.ts\nvar ollamaClientAdapter = ({\n ollama\n}) => ({\n client: ollama,\n requestHandlers: {\n \"^/v1/models$\": models12({ ollama }),\n \"^/(?:v1\|/?openai)/chat/completions$\": completions9({ ollama })\n }\n});\n\n// src/adapters/client/openRouterClientAdapter/models/get.ts\nvar get11 = ({\n openRouter\n}) => async (_url, _options) => {\n try {\n const data = await openRouter.models.list();\n const openaiModels = {\n object: \"list\",\n data: data.data.map((m) => ({\n id: m.id,\n object: \"model\",\n created: m.created,\n owned_by: m.id.split(\"/\")[0] \|\| \"openrouter\"\n }))\n };\n return new Response(JSON.stringify(openaiModels), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n } catch (error) {\n return new Response(JSON.stringify({\n error\n }), {\n status: 500,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/client/openRouterClientAdapter/models/index.ts\nvar models13 = ({\n openRouter\n}) => ({\n get: get11({ openRouter })\n});\n\n// src/adapters/client/openRouterClientAdapter/completions/normalizeComputerCall.ts\nvar MODEL_QUIRKS = {\n \"z-ai/glm-4.6v\": { normalizedCoords: true, cleanArtifacts: true },\n \"qwen/\": { fuzzyFallback: true },\n \"moonshotai/kimi-k2.5\": { relativeCoords: { referenceWidth: 1920, referenceHeight: 1080 } }\n};\nvar getQuirks = (model) => {\n for (const [prefix, quirks] of Object.entries(MODEL_QUIRKS)) {\n if (model.startsWith(prefix)) return quirks;\n }\n return {};\n};\nvar cleanTextArtifacts = (text) => text.replace(/<\\\|begin_of_box\\\|>/g, \"\").replace(/<\\\|end_of_box\\\|>/g, \"\").replace(/<arg_key>[^<]<\\/arg_key>/g, \"\").replace(/<\\/arg_value>/g, \"\").trim();\nvar KNOWN_ACTION_TYPES = [\"double_click\", \"screenshot\", \"keypress\", \"scroll\", \"click\", \"move\", \"type\", \"drag\", \"wait\"];\nvar splitCoordDigits = (numStr) => {\n for (let i = 1; i < numStr.length; i++) {\n const x = parseInt(numStr.slice(0, i));\n const y = parseInt(numStr.slice(i));\n if (x >= 0 && x <= 1e3 && y >= 0 && y <= 1e3) {\n return { x, y };\n }\n }\n return null;\n};\nvar cleanGlmAction = (action) => {\n const typeVal = action.type;\n if (typeof typeVal !== \"string\") return action;\n const argValueMatch = typeVal.match(/<arg_value>\\s(\\{[\\s\\S]\\})\\s$/);\n if (argValueMatch) {\n const inner = parseJson2(argValueMatch[1]);\n if (inner && typeof inner === \"object\") {\n return inner;\n }\n }\n const cleanedType = typeVal.replace(/<\\/?[^>]+>/g, \"\").replace(/\\n/g, \"\").trim();\n for (const actionType of KNOWN_ACTION_TYPES) {\n if (cleanedType.startsWith(actionType) && cleanedType !== actionType) {\n const rest = cleanedType.slice(actionType.length);\n const nums = rest.match(/\\d+/g);\n if (nums && nums.length >= 2) {\n return { ...action, type: actionType, x: parseInt(nums[0]), y: parseInt(nums[1]) };\n }\n if (nums && nums.length === 1 && nums[0].length >= 2) {\n const coords = splitCoordDigits(nums[0]);\n if (coords) {\n return { ...action, type: actionType, ...coords };\n }\n }\n return { ...action, type: actionType };\n }\n }\n if (cleanedType === typeVal) return action;\n return { ...action, type: cleanedType };\n};\nvar cleanGlmFields = (action) => {\n const result = { ...action };\n if (typeof result.x === \"string\") {\n const nums = result.x.match(/\\d+/g);\n if (nums && nums.length >= 2) {\n result.x = parseInt(nums[0]);\n if (result.y === void 0 \|\| typeof result.y === \"string\") {\n result.y = parseInt(nums[1]);\n }\n } else if (nums && nums.length === 1) {\n result.x = parseInt(nums[0]);\n }\n }\n if (typeof result.y === \"string\") {\n const nums = result.y.match(/\\d+/g);\n if (nums && nums.length >= 1) {\n result.y = parseInt(nums[0]);\n }\n }\n for (const key of [\"scroll_x\", \"scroll_y\"]) {\n if (typeof result[key] === \"string\") {\n const nums = result[key].match(/\\d+/g);\n if (nums) result[key] = parseInt(nums[0]);\n }\n }\n if (typeof result.type === \"string\") {\n result.type = result.type.replace(/<[^>]>/g, \"\").replace(/^\\{\|\\}$/g, \"\").replace(/\\n/g, \"\").trim();\n }\n return result;\n};\nvar applyArtifactCleanup = (action) => cleanGlmFields(cleanGlmAction(action));\nvar parseJson2 = (text) => {\n try {\n return JSON.parse(text);\n } catch {\n return void 0;\n }\n};\nvar extractJson = (text) => {\n const direct = parseJson2(text);\n if (direct) return direct;\n const codeBlockMatch = text.match(/```(?:json)?\\s([\\s\\S]?)```/);\n if (codeBlockMatch) {\n const parsed = parseJson2(codeBlockMatch[1].trim());\n if (parsed) return parsed;\n }\n const jsonMatch = text.match(/(\\{[\\s\\S]\\})\\s$/);\n if (jsonMatch) {\n const parsed = parseJson2(jsonMatch[1].trim());\n if (parsed) return parsed;\n }\n return void 0;\n};\nvar fuzzyExtractJson = (text) => {\n const clickMatch = text.match(/\"action\"\\s:\\s\"click\"\\s,\\s\"x\"\\s:\\s\\[?\\s(\\d+)\\s,\\s(\\d+)/);\n if (clickMatch) {\n return { action: { type: \"click\", x: parseInt(clickMatch[1]), y: parseInt(clickMatch[2]) } };\n }\n const actionTypeMatch = text.match(/\"type\"\\s:\\s\"(\\w+)\"/);\n if (actionTypeMatch) {\n const result = { type: actionTypeMatch[1] };\n const xMatch = text.match(/\"x\"\\s:\\s\\[?\\s(\\d+)/);\n const yMatch = text.match(/\"y\"\\s:\\s(\\d+)/);\n if (xMatch) result.x = parseInt(xMatch[1]);\n if (yMatch) {\n result.y = parseInt(yMatch[1]);\n } else if (xMatch) {\n const afterX = text.slice((xMatch.index ?? 0) + xMatch[0].length);\n const nextNum = afterX.match(/\\s,?\\s(\\d+)/);\n if (nextNum) result.y = parseInt(nextNum[1]);\n }\n const textMatch = text.match(/\"text\"\\s:\\s\"([^\"])\"/);\n if (textMatch) result.text = textMatch[1];\n return { action: result };\n }\n return void 0;\n};\nvar denormalize = (value, dimension) => Math.round(value / 1e3 * dimension);\nvar denormalizeAction = (action, displayWidth, displayHeight) => {\n const result = { ...action };\n if (typeof result.x === \"number\") {\n result.x = denormalize(result.x, displayWidth);\n }\n if (typeof result.y === \"number\") {\n result.y = denormalize(result.y, displayHeight);\n }\n if (Array.isArray(result.path)) {\n result.path = result.path.map((point) => {\n if (point && typeof point === \"object\") {\n return {\n ...point,\n ...typeof point.x === \"number\" ? { x: denormalize(point.x, displayWidth) } : {},\n ...typeof point.y === \"number\" ? { y: denormalize(point.y, displayHeight) } : {}\n };\n }\n return point;\n });\n }\n return result;\n};\nvar rescaleCoord = (value, displayDim, referenceDim) => {\n if (value <= 1) return Math.round(value * displayDim);\n return Math.round(value / referenceDim * displayDim);\n};\nvar rescaleRelativeAction = (action, displayWidth, displayHeight, referenceWidth, referenceHeight) => {\n const result = { ...action };\n if (typeof result.x === \"number\") {\n result.x = rescaleCoord(result.x, displayWidth, referenceWidth);\n }\n if (typeof result.y === \"number\") {\n result.y = rescaleCoord(result.y, displayHeight, referenceHeight);\n }\n if (Array.isArray(result.path)) {\n result.path = result.path.map((point) => {\n if (point && typeof point === \"object\") {\n return {\n ...point,\n ...typeof point.x === \"number\" ? { x: rescaleCoord(point.x, displayWidth, referenceWidth) } : {},\n ...typeof point.y === \"number\" ? { y: rescaleCoord(point.y, displayHeight, referenceHeight) } : {}\n };\n }\n return point;\n });\n }\n return result;\n};\nvar COORD_FIELDS = [\"x\", \"y\", \"text\", \"keys\", \"button\", \"direction\", \"scroll_x\", \"scroll_y\", \"path\"];\nvar normalizeStructure = (parsed, shouldCleanArtifacts) => {\n const clean = shouldCleanArtifacts ? (action) => applyArtifactCleanup(action) : (action) => action;\n if (parsed.action && typeof parsed.action === \"object\") {\n return { ...parsed, action: clean(parsed.action) };\n }\n if (typeof parsed.action === \"string\") {\n const actionObj = { type: parsed.action };\n const rest = {};\n for (const [key, value] of Object.entries(parsed)) {\n if (key === \"action\") continue;\n if (COORD_FIELDS.includes(key)) {\n actionObj[key] = value;\n } else {\n rest[key] = value;\n }\n }\n return { ...rest, action: clean(actionObj) };\n }\n if (typeof parsed.type === \"string\") {\n const actionObj = {};\n const rest = {};\n for (const [key, value] of Object.entries(parsed)) {\n if (key === \"type\" \|\| COORD_FIELDS.includes(key)) {\n actionObj[key] = value;\n } else {\n rest[key] = value;\n }\n }\n return { ...rest, action: clean(actionObj) };\n }\n return parsed;\n};\nvar denormalizeComputerCallArguments = ({\n argumentsText,\n displayWidth,\n displayHeight,\n model\n}) => {\n if (typeof argumentsText === \"object\" && argumentsText !== null) {\n argumentsText = JSON.stringify(argumentsText);\n }\n const quirks = getQuirks(model);\n let text = argumentsText;\n if (quirks.cleanArtifacts) {\n text = cleanTextArtifacts(text);\n }\n let parsed = extractJson(text);\n if (!parsed && (quirks.cleanArtifacts \|\| quirks.fuzzyFallback)) {\n parsed = fuzzyExtractJson(text);\n }\n if (!parsed \|\| typeof parsed !== \"object\") {\n return argumentsText;\n }\n const normalized = normalizeStructure(parsed, !!quirks.cleanArtifacts);\n if (quirks.normalizedCoords && normalized.action && typeof normalized.action === \"object\") {\n return JSON.stringify({\n ...normalized,\n action: denormalizeAction(\n normalized.action,\n displayWidth,\n displayHeight\n )\n });\n }\n if (quirks.relativeCoords && normalized.action && typeof normalized.action === \"object\") {\n return JSON.stringify({\n ...normalized,\n action: rescaleRelativeAction(\n normalized.action,\n displayWidth,\n displayHeight,\n quirks.relativeCoords.referenceWidth,\n quirks.relativeCoords.referenceHeight\n )\n });\n }\n return JSON.stringify(normalized);\n};\n\n// src/adapters/client/openRouterClientAdapter/completions/computerUseTool.ts\nvar buildComputerCallFunction = (model, displayWidth, displayHeight) => {\n const quirks = getQuirks(model);\n const coordDesc = quirks.normalizedCoords ? \"Coordinates use 0-1000 normalized scale (0,0=top-left, 1000,1000=bottom-right).\" : quirks.relativeCoords ? `Coordinates are relative (0.0-1.0) where 0.0,0.0 is top-left and 1.0,1.0 is bottom-right. Screen is ${displayWidth}x${displayHeight}.` : `Coordinates are in pixels (screen is ${displayWidth}x${displayHeight}).`;\n const xDesc = quirks.normalizedCoords ? \"X coordinate (0-1000 normalized)\" : quirks.relativeCoords ? \"X coordinate (0.0-1.0 relative, where 0.0=left edge, 1.0=right edge)\" : `X coordinate in pixels (0-${displayWidth})`;\n const yDesc = quirks.normalizedCoords ? \"Y coordinate (0-1000 normalized)\" : quirks.relativeCoords ? \"Y coordinate (0.0-1.0 relative, where 0.0=top edge, 1.0=bottom edge)\" : `Y coordinate in pixels (0-${displayHeight})`;\n return {\n name: \"computer_call\",\n description: `Perform a computer action. ${coordDesc}`,\n parameters: {\n type: \"object\",\n properties: {\n action: {\n type: \"object\",\n description: \"The action to perform\",\n properties: {\n type: {\n type: \"string\",\n enum: [\n \"screenshot\",\n \"click\",\n \"double_click\",\n \"type\",\n \"keypress\",\n \"scroll\",\n \"move\",\n \"drag\",\n \"wait\"\n ]\n },\n x: { type: \"number\", description: xDesc },\n y: { type: \"number\", description: yDesc },\n text: { type: \"string\", description: \"Text to type\" },\n keys: {\n type: \"array\",\n items: { type: \"string\" },\n description: \"Keys to press\"\n },\n button: {\n type: \"string\",\n enum: [\"left\", \"right\", \"wheel\"]\n },\n direction: {\n type: \"string\",\n enum: [\"up\", \"down\", \"left\", \"right\"]\n },\n scroll_x: { type: \"number\" },\n scroll_y: { type: \"number\" },\n path: {\n type: \"array\",\n items: {\n type: \"object\",\n properties: {\n x: { type: \"number\" },\n y: { type: \"number\" }\n }\n },\n description: \"Path for drag action\"\n }\n },\n required: [\"type\"]\n },\n pending_safety_checks: {\n type: \"array\",\n items: { type: \"object\" }\n }\n },\n required: [\"action\"]\n }\n };\n};\nvar transformTools = (tools, model) => {\n if (!tools \|\| tools.length === 0) {\n return { tools: tools ?? [], computerUseConfig: null };\n }\n let computerUseConfig = null;\n const transformed = tools.map((tool) => {\n if (tool.type === \"computer_use_preview\") {\n const config = tool.computer_use_preview ?? tool;\n computerUseConfig = {\n displayWidth: config.display_width ?? config.display_width_px ?? 1280,\n displayHeight: config.display_height ?? config.display_height_px ?? 720\n };\n return {\n type: \"function\",\n function: buildComputerCallFunction(model, computerUseConfig.displayWidth, computerUseConfig.displayHeight)\n };\n }\n return tool;\n });\n return { tools: transformed, computerUseConfig };\n};\n\n// src/adapters/client/openRouterClientAdapter/completions/post.ts\nvar ARTIFACT_TAGS = /<\\\|begin_of_box\\\|>\|<\\\|end_of_box\\\|>/g;\nvar sanitizeContent = (content) => {\n if (!content) return content;\n return content.replace(ARTIFACT_TAGS, \"\").trim();\n};\nvar convertScreenshotToolMessages = (messages5) => messages5.map((msg) => {\n if (msg.role !== \"tool\" \|\| typeof msg.content !== \"string\") return msg;\n try {\n const parsed = JSON.parse(msg.content);\n if (parsed.type === \"computer_screenshot\" && parsed.image_url) {\n return {\n ...msg,\n content: [\n { type: \"image_url\", image_url: { url: parsed.image_url } }\n ]\n };\n }\n } catch {\n }\n return msg;\n});\nvar resolveApiKey = async (apiKey) => {\n if (!apiKey) return \"\";\n return typeof apiKey === \"function\" ? await apiKey() : apiKey;\n};\nasync function* parseSSE(response) {\n const reader = response.body.getReader();\n const decoder = new TextDecoder();\n let buffer = \"\";\n try {\n while (true) {\n const { done, value } = await reader.read();\n if (done) break;\n buffer += decoder.decode(value, { stream: true });\n const lines = buffer.split(\"\\n\");\n buffer = lines.pop() ?? \"\";\n for (const line of lines) {\n const trimmed = line.trim();\n if (!trimmed.startsWith(\"data: \")) continue;\n const data = trimmed.slice(6);\n if (data === \"[DONE]\") return;\n try {\n yield JSON.parse(data);\n } catch {\n }\n }\n }\n } finally {\n reader.releaseLock();\n }\n}\nvar rawFetch = async (openRouter, body) => {\n const apiKey = await resolveApiKey(openRouter._options.apiKey);\n const baseURL = (openRouter._baseURL?.toString() ?? \"https://openrouter.ai/api/v1\").replace(/\\/+$/, \"\");\n const headers = {\n \"Content-Type\": \"application/json\",\n \"Authorization\": `Bearer ${apiKey}`\n };\n if (body.stream) {\n headers[\"Accept\"] = \"text/event-stream\";\n }\n if (openRouter._options.httpReferer) {\n headers[\"HTTP-Referer\"] = openRouter._options.httpReferer;\n }\n if (openRouter._options.xTitle) {\n headers[\"X-Title\"] = openRouter._options.xTitle;\n }\n const request = new Request(`${baseURL}/chat/completions`, {\n method: \"POST\",\n headers,\n body: JSON.stringify(body)\n });\n const httpClient = openRouter._options.httpClient;\n return httpClient ? httpClient.request(request) : fetch(request);\n};\nvar post10 = ({\n openRouter,\n provider\n}) => async (_url, options) => {\n const body = JSON.parse(options.body);\n const model = body.model;\n const { tools: transformedTools, computerUseConfig } = transformTools(body.tools, model);\n const resultOptions = {\n ...body,\n ...provider && !body.provider ? { provider } : {},\n ...computerUseConfig && body.messages ? { messages: convertScreenshotToolMessages(body.messages) } : {},\n ...transformedTools.length > 0 ? { tools: transformedTools } : {}\n };\n if (body.stream) {\n const response = await rawFetch(openRouter, resultOptions);\n if (!response.ok) {\n return new Response(response.body, {\n status: response.status,\n headers: { \"Content-Type\": response.headers.get(\"Content-Type\") ?? \"application/json\" }\n });\n }\n const shouldCleanArtifacts = getQuirks(model).cleanArtifacts;\n if (!computerUseConfig && !shouldCleanArtifacts) {\n return new Response(response.body, {\n status: response.status,\n headers: { \"Content-Type\": \"text/event-stream\" }\n });\n }\n if (!computerUseConfig) {\n const readableStream2 = new ReadableStream({\n async start(controller) {\n for await (const chunk of parseSSE(response)) {\n const delta = chunk.choices?.[0];\n const d = delta?.delta;\n if (d?.content && typeof d.content === \"string\") {\n d.content = sanitizeContent(d.content);\n }\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(readableStream2, {\n headers: { \"Content-Type\": \"text/event-stream\" }\n });\n }\n const { displayWidth, displayHeight } = computerUseConfig;\n const readableStream = new ReadableStream({\n async start(controller) {\n const computerCallIndices = /* @__PURE__ / new Set();\n const argumentBuffers = / @__PURE__ / new Map();\n const emittedIndices = / @__PURE__ / new Set();\n for await (const chunk of parseSSE(response)) {\n const choices = chunk.choices ?? [];\n const choice = choices[0];\n const delta = choice?.delta;\n const toolCalls = delta?.tool_calls;\n if (!toolCalls) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\n\n`);\n continue;\n }\n const passThrough = [];\n for (const tc of toolCalls) {\n const fn = tc.function;\n if (fn?.name === \"computer_call\") {\n computerCallIndices.add(tc.index);\n const initialArgs = fn?.arguments ?? \"\";\n argumentBuffers.set(tc.index, initialArgs);\n if (initialArgs) {\n try {\n JSON.parse(initialArgs);\n const denormalized = denormalizeComputerCallArguments({\n argumentsText: initialArgs,\n displayWidth,\n displayHeight,\n model\n });\n passThrough.push({\n ...tc,\n function: { ...fn, arguments: denormalized }\n });\n emittedIndices.add(tc.index);\n continue;\n } catch {\n }\n }\n passThrough.push({\n ...tc,\n function: { ...fn, arguments: \"\" }\n });\n continue;\n }\n if (computerCallIndices.has(tc.index)) {\n const buf = (argumentBuffers.get(tc.index) ?? \"\") + (fn?.arguments ?? \"\");\n argumentBuffers.set(tc.index, buf);\n if (!emittedIndices.has(tc.index)) {\n try {\n JSON.parse(buf);\n const denormalized = denormalizeComputerCallArguments({\n argumentsText: buf,\n displayWidth,\n displayHeight,\n model\n });\n passThrough.push({\n index: tc.index,\n function: { arguments: denormalized }\n });\n emittedIndices.add(tc.index);\n } catch {\n }\n }\n continue;\n }\n passThrough.push(tc);\n }\n if (passThrough.length > 0) {\n const modifiedChunk = {\n ...chunk,\n choices: [{\n ...choice,\n delta: {\n ...delta,\n tool_calls: passThrough\n }\n }]\n };\n controller.enqueue(`data: ${JSON.stringify(modifiedChunk)}\n\n`);\n }\n }\n for (const [index, buf] of Array.from(argumentBuffers)) {\n if (!emittedIndices.has(index) && buf) {\n const denormalized = denormalizeComputerCallArguments({\n argumentsText: buf,\n displayWidth,\n displayHeight,\n model\n });\n const flushChunk = {\n object: \"chat.completion.chunk\",\n choices: [{\n index: 0,\n delta: {\n tool_calls: [{\n index,\n function: { arguments: denormalized }\n }]\n }\n }]\n };\n controller.enqueue(`data: ${JSON.stringify(flushChunk)}\n\n`);\n }\n }\n controller.close();\n }\n });\n return new Response(readableStream, {\n headers: { \"Content-Type\": \"text/event-stream\" }\n });\n } else {\n try {\n const response = await rawFetch(openRouter, resultOptions);\n if (!response.ok) {\n return new Response(response.body, {\n status: response.status,\n headers: { \"Content-Type\": response.headers.get(\"Content-Type\") ?? \"application/json\" }\n });\n }\n const data = await response.json();\n if (computerUseConfig) {\n for (const choice of data.choices ?? []) {\n const message = choice.message;\n const toolCalls = message?.tool_calls ?? [];\n for (const tc of toolCalls) {\n const fn = tc.function;\n if (fn?.name === \"computer_call\") {\n fn.arguments = denormalizeComputerCallArguments({\n argumentsText: fn.arguments,\n displayWidth: computerUseConfig.displayWidth,\n displayHeight: computerUseConfig.displayHeight,\n model\n });\n }\n }\n }\n }\n if (getQuirks(model).cleanArtifacts) {\n for (const choice of data.choices ?? []) {\n const message = choice.message;\n if (message?.content && typeof message.content === \"string\") {\n message.content = sanitizeContent(message.content);\n }\n }\n }\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: { \"Content-Type\": \"application/json\" }\n });\n } catch (error) {\n return new Response(JSON.stringify({ error }), {\n status: 500,\n headers: { \"Content-Type\": \"application/json\" }\n });\n }\n }\n};\n\n// src/adapters/client/openRouterClientAdapter/completions/index.ts\nvar completions10 = ({\n openRouter,\n provider\n}) => ({\n post: post10({ openRouter, provider })\n});\n\n// src/adapters/client/openRouterClientAdapter/index.ts\nvar openRouterClientAdapter = ({\n openRouter,\n provider\n}) => ({\n client: openRouter,\n requestHandlers: {\n \"^/v1/models$\": models13({ openRouter }),\n \"^/(?:v1\|/?openai)/chat/completions$\": completions10({ openRouter, provider })\n }\n});\n\n// src/adapters/run/completionsRunAdapter/index.ts\nvar import_lodash = __toESM(require(\"lodash\"), 1);\nvar import_radash8 = require(\"radash\");\nvar import_dayjs = __toESM(require(\"dayjs\"), 1);\n\n// src/adapters/run/completionsRunAdapter/messages/index.ts\nvar import_radash7 = require(\"radash\");\n\n// src/adapters/run/completionsRunAdapter/messages/serializeMessage.ts\nvar import_radash6 = require(\"radash\");\nvar validToolCallContentTypes = [\n \"image\",\n \"image_url\",\n \"text\"\n];\nvar serializeToolContent = ({\n toolCall\n}) => {\n if ((0, import_radash6.isArray)(toolCall.function.output)) {\n const isEveryToolPartValid = toolCall.function.output.every((toolPart) => {\n if (!(0, import_radash6.isObject)(toolPart)) return false;\n return validToolCallContentTypes.includes(toolPart.type);\n });\n if (isEveryToolPartValid) {\n return toolCall.function.output;\n }\n return JSON.stringify(toolCall.function.output);\n }\n return toolCall.function.output ?? \"\";\n};\nvar serializeToolCall = ({\n toolCall\n}) => ({\n tool_call_id: toolCall.id,\n role: \"tool\",\n name: toolCall.function.name,\n content: serializeToolContent({\n toolCall\n })\n});\nvar serializeMessageWithContent = ({\n message\n}) => ({\n role: message.role,\n content: serializeContent({\n content: message.content\n }),\n ...message?.metadata?.toolCalls ? { tool_calls: message.metadata.toolCalls } : {}\n});\nvar serializeContent = ({\n content\n}) => content.map((content2) => content2.text.value).join(\"\\n\");\nvar serializeMessage3 = ({\n message\n}) => {\n const result = [serializeMessageWithContent({ message })];\n const run4 = message.run;\n if (!run4) return result;\n const messageToolCalls = message.metadata?.toolCalls \|\| [];\n messageToolCalls.forEach((tc) => {\n const runStep = run4.runSteps.find((rs) => {\n if (rs.type !== \"tool_calls\") return false;\n const stepDetails2 = rs.step_details;\n if (!Array.isArray(stepDetails2.tool_calls)) return false;\n return stepDetails2.tool_calls.some((rsTc) => rsTc.type === \"function\" && rsTc.id === tc.id);\n });\n if (!runStep) return;\n const stepDetails = runStep.step_details;\n if (!Array.isArray(stepDetails.tool_calls)) return;\n const toolCall = stepDetails.tool_calls.find((rsTc) => rsTc.type === \"function\" && rsTc.id === tc.id);\n if (toolCall && toolCall.type === \"function\") {\n result.push(serializeToolCall({ toolCall }));\n }\n });\n return result;\n};\n\n// src/adapters/run/completionsRunAdapter/messages/index.ts\nvar messages = async ({\n run: run4,\n getMessages: getMessages2\n}) => [\n ...run4.instructions ? [{\n role: \"system\",\n content: run4.instructions\n }] : [],\n ...(0, import_radash7.flat)((await getMessages2()).map((message) => serializeMessage3({ message })))\n];\n\n// src/adapters/run/completionsRunAdapter/index.ts\nvar updatedToolCall = ({\n toolCall,\n delta\n}) => {\n if (!toolCall) return (0, import_radash8.omit)(delta, [\"index\"]);\n const result = import_lodash.default.cloneDeep(toolCall);\n for (const [key, value] of Object.entries(delta.function)) {\n result.function[key] = `${result.function[key] ?? \"\"}${value}`;\n }\n return result;\n};\nvar toolCallsData = ({\n prevToolCalls,\n delta\n}) => {\n if (!prevToolCalls) {\n return delta.tool_calls.map((tc) => ({\n id: (0, import_radash8.uid)(24),\n type: tc.type ?? \"function\",\n ...(0, import_radash8.omit)(tc, [\"index\"])\n }));\n }\n const newToolCalls = import_lodash.default.cloneDeep(prevToolCalls);\n for (const runStepDelta of delta.tool_calls) {\n newToolCalls[runStepDelta.index] = updatedToolCall({\n toolCall: newToolCalls[runStepDelta.index],\n delta: runStepDelta\n });\n }\n return newToolCalls;\n};\nvar completionsRunAdapter = () => {\n return {\n handleRun: async ({\n client,\n run: run4,\n onEvent: onEvent2,\n getMessages: getMessages2\n }) => {\n if (run4.status !== \"queued\") return;\n onEvent2({\n event: \"thread.run.in_progress\",\n data: {\n ...run4,\n status: \"in_progress\"\n }\n });\n const opts = {\n messages: await messages({\n run: run4,\n getMessages: getMessages2\n }),\n model: run4.model,\n stream: true,\n response_format: run4.response_format,\n ...(0, import_radash8.isEmpty)(run4.tools) ? {} : { tools: run4.tools }\n };\n let providerResponse;\n try {\n providerResponse = await client.chat.completions.create(opts);\n } catch (e) {\n console.error(e);\n return onEvent2({\n event: \"thread.run.failed\",\n data: {\n ...run4,\n failed_at: (0, import_dayjs.default)().unix(),\n status: \"in_progress\",\n last_error: {\n code: \"server_error\",\n message: `${e?.message ?? \"\"} ${e?.cause?.message ?? \"\"}`\n }\n }\n });\n }\n let message = await onEvent2({\n event: \"thread.message.created\",\n data: {\n id: \"THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID\",\n object: \"thread.message\",\n completed_at: null,\n run_id: run4.id,\n created_at: (0, import_dayjs.default)().unix(),\n assistant_id: run4.assistant_id,\n incomplete_at: null,\n incomplete_details: null,\n metadata: {},\n attachments: [],\n thread_id: run4.thread_id,\n content: [{ text: { value: \"\", annotations: [] }, type: \"text\" }],\n role: \"assistant\",\n status: \"in_progress\"\n }\n });\n onEvent2({\n event: \"thread.run.step.created\",\n data: {\n id: \"THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID\",\n object: \"thread.run.step\",\n run_id: run4.id,\n assistant_id: run4.assistant_id,\n thread_id: run4.thread_id,\n type: \"message_creation\",\n status: \"completed\",\n completed_at: (0, import_dayjs.default)().unix(),\n created_at: (0, import_dayjs.default)().unix(),\n expired_at: null,\n last_error: null,\n metadata: {},\n failed_at: null,\n cancelled_at: null,\n usage: null,\n step_details: {\n type: \"message_creation\",\n message_creation: {\n message_id: message.id\n }\n }\n }\n });\n let toolCallsRunStep;\n let currentContent = \"\";\n let currentToolCalls;\n for await (const chunk of providerResponse) {\n const choices = chunk.choices ?? [];\n const choice = choices[0];\n if (!choice) continue;\n const delta = choice.delta;\n if (delta.content) {\n currentContent = `${currentContent}${delta.content ?? \"\"}`;\n }\n if (delta.tool_calls) {\n if (!toolCallsRunStep) {\n toolCallsRunStep = await onEvent2({\n event: \"thread.run.step.created\",\n data: {\n id: \"THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID\",\n object: \"thread.run.step\",\n run_id: run4.id,\n assistant_id: run4.assistant_id,\n thread_id: run4.thread_id,\n type: \"tool_calls\",\n status: \"in_progress\",\n completed_at: null,\n created_at: (0, import_dayjs.default)().unix(),\n expired_at: null,\n last_error: null,\n metadata: {},\n failed_at: null,\n cancelled_at: null,\n usage: null,\n step_details: {\n type: \"tool_calls\",\n tool_calls: []\n }\n }\n });\n }\n onEvent2({\n event: \"thread.run.step.delta\",\n data: {\n object: \"thread.run.step.delta\",\n run_id: run4.id,\n id: toolCallsRunStep.id,\n delta: {\n step_details: {\n type: \"tool_calls\",\n tool_calls: delta.tool_calls.map((tc) => ({\n id: (0, import_radash8.uid)(24),\n type: tc.type ?? \"function\",\n ...tc\n }))\n }\n }\n }\n });\n currentToolCalls = toolCallsData({ prevToolCalls: currentToolCalls, delta });\n }\n if (delta.content) {\n onEvent2({\n event: \"thread.message.delta\",\n data: {\n id: message.id,\n delta: {\n content: [\n {\n type: \"text\",\n index: 0,\n text: {\n value: delta.content\n }\n }\n ]\n }\n }\n });\n }\n }\n message = await onEvent2({\n event: \"thread.message.completed\",\n data: {\n ...message,\n status: \"completed\",\n content: [{ text: { value: currentContent, annotations: [] }, type: \"text\" }],\n tool_calls: currentToolCalls\n }\n });\n const messageToolCalls = message.toolCalls ?? [];\n const functionToolCalls = messageToolCalls.filter(\n (toolCall) => toolCall.type === \"function\"\n );\n const pendingFunctionToolCalls = functionToolCalls.filter(\n (toolCall) => !toolCall.function?.output\n );\n if ((0, import_radash8.isEmpty)(pendingFunctionToolCalls)) {\n if (toolCallsRunStep) {\n toolCallsRunStep = await onEvent2({\n event: \"thread.run.step.completed\",\n data: {\n ...toolCallsRunStep,\n status: \"completed\",\n completed_at: (0, import_dayjs.default)().unix(),\n step_details: {\n type: \"tool_calls\",\n tool_calls: currentToolCalls ?? []\n }\n }\n });\n }\n return onEvent2({\n event: \"thread.run.completed\",\n data: {\n ...run4,\n status: \"completed\",\n completed_at: (0, import_dayjs.default)().unix()\n }\n });\n }\n const requiredToolCalls = pendingFunctionToolCalls.map(\n (toolCall) => {\n const args = toolCall.function?.arguments ?? \"\";\n if (toolCall.function?.name === \"computer_call\") {\n let parsedArguments = {};\n try {\n parsedArguments = JSON.parse(args \|\| \"{}\");\n } catch {\n parsedArguments = {};\n }\n const computerCall = {\n action: parsedArguments?.action ?? parsedArguments ?? {},\n pending_safety_checks: Array.isArray(parsedArguments?.pending_safety_checks) ? parsedArguments.pending_safety_checks : []\n };\n return {\n id: toolCall.id,\n type: \"computer_call\",\n computer_call: computerCall\n };\n }\n return {\n id: toolCall.id,\n type: \"function\",\n function: {\n name: toolCall.function?.name ?? \"\",\n arguments: args\n }\n };\n }\n );\n return onEvent2({\n event: \"thread.run.requires_action\",\n data: {\n ...run4,\n status: \"requires_action\",\n required_action: {\n type: \"submit_tool_outputs\",\n submit_tool_outputs: {\n tool_calls: requiredToolCalls\n }\n }\n }\n });\n }\n };\n};\n\n// src/lib/messages/messagesRegexp.ts\nvar messagesRegexp = \"^/(?:v1\|/?openai)/threads/([^/]+)/messages$\";\n\n// src/lib/runs/runsRegexp.ts\nvar runsRegexp = \"^/(?:v1\|/?openai)/threads/([^/]+)/runs$\";\n\n// src/lib/runs/runRegexp.ts\nvar runRegexp = \"^/(?:v1\|/?openai)/threads/([^/]+)/runs/([^/]+)$\";\n\n// src/lib/runs/submitToolOutputsRegexp.ts\nvar submitToolOutputsRegexp = \"^/(?:v1\|/?openai)/threads/([^/]+)/runs/([^/]+)/submit_tool_outputs$\";\n\n// src/lib/steps/stepsRegexp.ts\nvar stepsRegexp = \"^/(?:v1\|/?openai)/threads/([^/]+)/runs/([^/]+)/steps$\";\n\n// src/adapters/storage/prismaStorageAdapter/threads/post.ts\nvar import_dayjs3 = __toESM(require(\"dayjs\"), 1);\n\n// src/adapters/storage/prismaStorageAdapter/threads/serializeThread.ts\nvar import_dayjs2 = __toESM(require(\"dayjs\"), 1);\nvar serializeThread = ({\n thread\n}) => ({\n id: thread.id,\n object: \"thread\",\n created_at: (0, import_dayjs2.default)(thread.createdAt).unix(),\n metadata: thread.metadata,\n // TODO\n tool_resources: null\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/post.ts\nvar post11 = ({\n prisma\n}) => async (_urlString, options) => {\n if (!options.body) {\n throw new Error(\"No body provided\");\n }\n const body = JSON.parse(options.body);\n const messages5 = body.messages \|\| [];\n const metadataRecord = body.metadata \|\| {};\n const assistantId = typeof metadataRecord.assistantId === \"string\" ? metadataRecord.assistantId : void 0;\n if (!assistantId) {\n throw new Error(\"assistantId is required to create a thread\");\n }\n const initialCreatedAt = (0, import_dayjs3.default)().subtract(messages5.length, \"seconds\");\n const messageData = messages5.map((message, index) => ({\n role: message.role === \"user\" ? \"USER\" : \"ASSISTANT\",\n content: [\n {\n type: \"text\",\n text: {\n annotations: [],\n value: message.content\n }\n }\n ],\n attachments: message.attachments ?? [],\n metadata: message.metadata,\n createdAt: initialCreatedAt.add(index, \"seconds\").toDate()\n }));\n const threadData = {\n metadata: metadataRecord,\n assistant: {\n connect: {\n id: assistantId\n }\n },\n messages: {\n create: messageData\n }\n };\n const thread = await prisma.thread.create({\n data: threadData\n });\n return new Response(JSON.stringify(\n serializeThread({ thread })\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/index.ts\nvar threads = ({\n prisma\n}) => ({\n post: post11({ prisma })\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/messages/post.ts\nvar import_radash10 = require(\"radash\");\n\n// src/adapters/storage/prismaStorageAdapter/threads/messages/serializeMessage.ts\nvar import_dayjs4 = __toESM(require(\"dayjs\"), 1);\nvar import_radash9 = require(\"radash\");\nvar serializeMessage4 = ({\n message\n}) => ({\n id: message.id,\n object: \"thread.message\",\n created_at: (0, import_dayjs4.default)(message.createdAt).unix(),\n thread_id: message.threadId,\n completed_at: message.completedAt ? (0, import_dayjs4.default)(message.completedAt).unix() : null,\n incomplete_at: message.incompleteAt ? (0, import_dayjs4.default)(message.incompleteAt).unix() : null,\n incomplete_details: message.incompleteDetails,\n role: message.role.toLowerCase(),\n content: message.content,\n assistant_id: message.assistantId,\n run_id: message.runId,\n attachments: message.attachments,\n status: message.status.toLowerCase(),\n metadata: (0, import_radash9.assign)(message.metadata ?? {}, message.toolCalls ? { toolCalls: message.toolCalls } : {})\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/messages/post.ts\nvar messageContentBlocks = ({\n content\n}) => {\n if ((0, import_radash10.isArray)(content)) {\n return content.map((item) => {\n if (item.type === \"text\") {\n return {\n type: \"text\",\n text: {\n value: item.text ?? \"\",\n annotations: []\n }\n };\n }\n return item;\n });\n }\n return [\n {\n type: \"text\",\n text: {\n value: content ?? \"\",\n annotations: []\n }\n }\n ];\n};\nvar post12 = ({\n prisma\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp));\n if (!options.body) {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const { role, content, metadata } = body;\n const message = await prisma.message.create({\n data: {\n threadId,\n content: messageContentBlocks({ content }),\n role: role === \"user\" ? \"USER\" : \"ASSISTANT\",\n metadata: metadata ?? {}\n }\n });\n return new Response(JSON.stringify(\n serializeMessage4({ message })\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/messages/get.ts\nvar import_radash11 = require(\"radash\");\nvar get12 = ({\n prisma\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp));\n const {\n limit,\n order,\n after\n } = (0, import_radash11.assign)({\n limit: \"20\",\n order: \"desc\"\n // after: null,\n }, Object.fromEntries(url.searchParams));\n const pageSize = parseInt(limit);\n const messagesPlusOne = await prisma.message.findMany({\n where: { threadId },\n take: pageSize + 1,\n orderBy: { createdAt: order === \"asc\" ? \"asc\" : \"desc\" },\n ...after && {\n skip: 1,\n cursor: { id: after }\n }\n });\n const messages5 = messagesPlusOne.slice(0, pageSize);\n return new Response(JSON.stringify({\n data: messages5.map((message) => serializeMessage4({ message })),\n has_more: messagesPlusOne.length > pageSize,\n last_id: (0, import_radash11.last)(messages5)?.id ?? null\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/messages/index.ts\nvar messages2 = ({\n prisma\n}) => ({\n post: post12({ prisma }),\n get: get12({ prisma })\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/get.ts\nvar import_radash12 = require(\"radash\");\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/serializeRun.ts\nvar import_dayjs5 = __toESM(require(\"dayjs\"), 1);\nvar serializeRun = ({\n run: run4\n}) => ({\n id: run4.id,\n object: \"thread.run\",\n created_at: (0, import_dayjs5.default)(run4.createdAt).unix(),\n thread_id: run4.threadId,\n assistant_id: run4.assistantId,\n status: run4.status.toLowerCase(),\n required_action: run4.requiredAction,\n last_error: run4.lastError,\n expires_at: (0, import_dayjs5.default)(run4.expiresAt).unix(),\n started_at: run4.startedAt ? (0, import_dayjs5.default)(run4.startedAt).unix() : null,\n cancelled_at: run4.cancelledAt ? (0, import_dayjs5.default)(run4.cancelledAt).unix() : null,\n failed_at: run4.failedAt ? (0, import_dayjs5.default)(run4.failedAt).unix() : null,\n completed_at: run4.completedAt ? (0, import_dayjs5.default)(run4.completedAt).unix() : null,\n model: run4.model,\n instructions: run4.instructions,\n tools: run4.tools,\n metadata: run4.metadata,\n usage: run4.usage,\n truncation_strategy: {\n type: \"auto\"\n },\n response_format: {\n type: \"text\"\n },\n // TODO\n incomplete_details: null,\n max_completion_tokens: null,\n max_prompt_tokens: null,\n tool_choice: \"auto\",\n parallel_tool_calls: true\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/mapPrismaRun.ts\nvar mapPrismaRun = (run4) => ({\n id: run4.id,\n threadId: run4.threadId,\n assistantId: run4.assistantId,\n status: run4.status,\n requiredAction: run4.requiredAction,\n lastError: run4.lastError,\n expiresAt: run4.expiresAt,\n startedAt: run4.startedAt ?? null,\n cancelledAt: run4.cancelledAt ?? null,\n failedAt: run4.failedAt ?? null,\n completedAt: run4.completedAt ?? null,\n model: run4.model,\n instructions: run4.instructions,\n tools: run4.tools,\n metadata: run4.metadata,\n usage: run4.usage,\n truncationStrategy: run4.truncationStrategy,\n responseFormat: run4.responseFormat,\n createdAt: run4.createdAt,\n updatedAt: run4.updatedAt\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/get.ts\nvar get13 = ({\n prisma\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp));\n const {\n limit,\n order,\n after\n } = (0, import_radash12.assign)({\n limit: \"20\",\n order: \"desc\"\n // after: null,\n }, Object.fromEntries(url.searchParams));\n const pageSize = parseInt(limit, 10);\n const runsPlusOne = await prisma.run.findMany({\n where: { threadId },\n take: pageSize + 1,\n orderBy: { createdAt: order === \"asc\" ? \"asc\" : \"desc\" },\n ...after && {\n skip: 1,\n cursor: { id: after }\n }\n });\n const runs5 = runsPlusOne.slice(0, pageSize);\n return new Response(JSON.stringify({\n data: runs5.map((run4) => serializeRun({ run: mapPrismaRun(run4) })),\n has_more: runsPlusOne.length > pageSize,\n last_id: runs5.at(-1)?.id ?? null\n }), {\n status: 200,\n headers: { \"Content-Type\": \"application/json\" }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/post.ts\nvar import_dayjs7 = __toESM(require(\"dayjs\"), 1);\nvar import_radash13 = require(\"radash\");\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunInProgress.ts\nvar threadRunInProgress = ({\n prisma,\n event,\n controller\n}) => {\n controller.enqueue(event);\n return prisma.run.update({\n where: {\n id: event.data.id\n },\n data: {\n status: \"IN_PROGRESS\" / IN_PROGRESS /\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunFailed.ts\nvar threadRunFailed = ({\n prisma,\n event,\n controller\n}) => {\n controller.enqueue(event);\n return prisma.run.update({\n where: {\n id: event.data.id\n },\n data: {\n status: \"FAILED\" / FAILED /,\n failedAt: event.data.failed_at,\n ...event.data.last_error != null ? { lastError: event.data.last_error } : {}\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunCompleted.ts\nvar threadRunCompleted = ({\n prisma,\n event,\n controller\n}) => {\n controller.enqueue(event);\n return prisma.run.update({\n where: {\n id: event.data.id\n },\n data: {\n status: \"COMPLETED\" / COMPLETED /,\n requiredAction: void 0\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunRequiresAction.ts\nvar threadRunRequiresAction = ({\n prisma,\n event,\n controller\n}) => {\n controller.enqueue(event);\n return prisma.run.update({\n where: {\n id: event.data.id\n },\n data: {\n status: \"REQUIRES_ACTION\" / REQUIRES_ACTION /,\n ...event.data.required_action != null ? { requiredAction: event.data.required_action } : {}\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/steps/serializeRunStep.ts\nvar import_dayjs6 = __toESM(require(\"dayjs\"), 1);\nvar serializeRunStep = ({\n runStep\n}) => ({\n id: runStep.id,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs6.default)(runStep.createdAt).unix(),\n assistant_id: runStep.assistantId,\n thread_id: runStep.threadId,\n run_id: runStep.runId,\n type: runStep.type.toLowerCase(),\n status: runStep.status.toLowerCase(),\n // @ts-ignore-next-line\n step_details: runStep.stepDetails,\n last_error: runStep.lastError,\n expired_at: runStep.expiredAt ? (0, import_dayjs6.default)(runStep.expiredAt).unix() : null,\n cancelled_at: runStep.cancelledAt ? (0, import_dayjs6.default)(runStep.cancelledAt).unix() : null,\n failed_at: runStep.failedAt ? (0, import_dayjs6.default)(runStep.failedAt).unix() : null,\n completed_at: runStep.completedAt ? (0, import_dayjs6.default)(runStep.completedAt).unix() : null,\n metadata: runStep.metadata,\n usage: runStep.usage\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunStepCreated.ts\nvar type = (event) => {\n if (event.data.type === \"message_creation\") return \"MESSAGE_CREATION\" / MESSAGE_CREATION /;\n if (event.data.type === \"tool_calls\") return \"TOOL_CALLS\" / TOOL_CALLS /;\n throw new Error(`Unknown type: ${event.data.type}`);\n};\nvar status = (event) => {\n if (event.data.status === \"in_progress\") return \"IN_PROGRESS\" / IN_PROGRESS /;\n if (event.data.status === \"cancelled\") return \"CANCELLED\" / CANCELLED /;\n if (event.data.status === \"completed\") return \"COMPLETED\" / COMPLETED /;\n if (event.data.status === \"failed\") return \"FAILED\" / FAILED /;\n if (event.data.status === \"expired\") return \"EXPIRED\" / EXPIRED /;\n throw new Error(`Unknown status: ${event.data.status}`);\n};\nvar threadRunStepCreated = async ({\n prisma,\n event,\n controller\n}) => {\n const runStep = await prisma.runStep.create({\n data: {\n runId: event.data.run_id,\n assistantId: event.data.assistant_id,\n threadId: event.data.thread_id,\n type: type(event),\n status: status(event),\n stepDetails: event.data.step_details,\n completedAt: event.data.completed_at\n }\n });\n const serializedRunStep = serializeRunStep({ runStep });\n controller.enqueue({\n ...event,\n data: serializedRunStep\n });\n return serializedRunStep;\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunStepDelta.ts\nvar threadRunStepDelta = ({\n event,\n controller\n}) => controller.enqueue(event);\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadRunStepCompleted.ts\nvar threadRunStepCompleted = async ({\n prisma,\n event,\n controller\n}) => {\n controller.enqueue(event);\n await prisma.runStep.update({\n where: {\n id: event.data.id\n },\n data: {\n status: \"COMPLETED\" / COMPLETED /,\n stepDetails: event.data.step_details,\n completedAt: event.data.completed_at\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadMessageCreated.ts\nvar status2 = (event) => {\n if (event.data.status === \"completed\") return \"COMPLETED\" / COMPLETED /;\n if (event.data.status === \"in_progress\") return \"IN_PROGRESS\" / IN_PROGRESS /;\n if (event.data.status === \"incomplete\") return \"INCOMPLETE\" / INCOMPLETE /;\n throw new Error(`Unknown status: ${event.data.status}`);\n};\nvar threadMessageCreated = async ({\n prisma,\n event,\n controller\n}) => {\n const message = await prisma.message.create({\n data: {\n threadId: event.data.thread_id,\n content: event.data.content,\n role: event.data.role === \"assistant\" ? \"ASSISTANT\" / ASSISTANT / : \"USER\" / USER /,\n assistantId: event.data.assistant_id,\n runId: event.data.run_id,\n status: status2(event)\n }\n });\n const serializedMessage = serializeMessage4({ message });\n controller.enqueue({\n ...event,\n data: serializedMessage\n });\n return serializedMessage;\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadMessageDelta.ts\nvar threadMessageDelta = ({\n event,\n controller\n}) => controller.enqueue(event);\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/threadMessageCompleted.ts\nvar threadMessageCompleted = async ({\n prisma,\n event,\n controller\n}) => {\n controller.enqueue(event);\n const toolCalls = event.data.tool_calls;\n if (toolCalls !== void 0) {\n const latestRunStep = await prisma.runStep.findFirst({\n where: {\n threadId: event.data.thread_id,\n type: \"TOOL_CALLS\" / TOOL_CALLS /\n },\n orderBy: {\n createdAt: \"desc\"\n }\n });\n if (!latestRunStep) {\n throw new Error(\"No run step found\");\n }\n await prisma.runStep.update({\n where: {\n id: latestRunStep.id\n },\n data: {\n stepDetails: {\n type: \"tool_calls\",\n tool_calls: toolCalls\n }\n }\n });\n }\n return prisma.message.update({\n where: {\n id: event.data.id\n },\n data: {\n status: \"COMPLETED\" / COMPLETED /,\n ...event.data.content ? { content: event.data.content } : {},\n ...toolCalls !== void 0 ? { toolCalls } : {}\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/handlers/index.ts\nvar handlers = {\n \"thread.run.in_progress\": threadRunInProgress,\n \"thread.run.failed\": threadRunFailed,\n \"thread.run.completed\": threadRunCompleted,\n \"thread.run.requires_action\": threadRunRequiresAction,\n \"thread.run.step.created\": threadRunStepCreated,\n \"thread.run.step.delta\": threadRunStepDelta,\n \"thread.run.step.completed\": threadRunStepCompleted,\n \"thread.message.created\": threadMessageCreated,\n \"thread.message.delta\": threadMessageDelta,\n \"thread.message.completed\": threadMessageCompleted\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/onEvent/index.ts\nvar onEvent = ({\n prisma,\n controller\n}) => (event) => {\n const handler = handlers[event.event];\n if (!handler) {\n console.log(\"No handler for event\", event);\n return;\n }\n return handler({ prisma, controller, event });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/getMessages.ts\nvar getTake = ({\n run: run4\n}) => {\n if ([\"auto\", \"disabled\"].includes(run4.truncationStrategy.type)) {\n return null;\n }\n if (run4.truncationStrategy.type === \"last_messages\") {\n if (!run4.truncationStrategy.last_messages) {\n throw new Error(\"Truncation strategy last_messages is required\");\n }\n return -run4.truncationStrategy.last_messages;\n }\n throw new Error(`Unsupported truncation strategy type: ${run4.truncationStrategy.type}`);\n};\nvar getMessages = ({\n prisma,\n run: run4\n}) => async () => {\n const take = getTake({\n run: run4\n });\n const messages5 = await prisma.message.findMany({\n where: {\n threadId: run4.threadId\n },\n include: {\n run: {\n include: {\n runSteps: true\n }\n }\n },\n orderBy: {\n createdAt: \"asc\"\n },\n ...take ? { take } : {}\n });\n return messages5.map((message) => ({\n ...serializeMessage4({ message }),\n run: message.run ? {\n ...serializeRun({ run: mapPrismaRun(message.run) }),\n runSteps: message.run.runSteps.map((runStep) => serializeRunStep({ runStep }))\n } : null\n }));\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/post.ts\nvar post13 = ({\n prisma,\n runAdapter\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp));\n if (!options.body) {\n throw new Error(\"No body provided\");\n }\n const body = JSON.parse(options.body);\n const { assistant_id, stream } = body;\n const assistant = await prisma.assistant.findUnique({\n where: {\n id: assistant_id\n }\n });\n if (!assistant) {\n throw new Error(\"Assistant not found\");\n }\n const {\n model,\n instructions,\n // additional_instructions,\n tools,\n metadata,\n response_format,\n truncation_strategy\n } = (0, import_radash13.assign)({\n model: assistant.modelSlug,\n instructions: \"\",\n additional_instructions: null,\n truncation_strategy: {\n type: \"auto\"\n },\n response_format: {\n type: \"text\"\n }\n // tools: [],\n // metadata: {},\n }, body);\n const run4 = await prisma.run.create({\n data: {\n status: \"QUEUED\",\n expiresAt: (0, import_dayjs7.default)().add(1, \"hour\").unix(),\n model,\n instructions,\n tools,\n metadata,\n thread: {\n connect: {\n id: threadId\n }\n },\n assistant: {\n connect: {\n id: assistant_id\n }\n },\n truncationStrategy: truncation_strategy,\n responseFormat: response_format\n }\n });\n const data = serializeRun({ run: run4 });\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n run: data,\n onEvent: onEvent({\n controller: {\n ...controller,\n enqueue: (data2) => {\n controller.enqueue(`data: ${JSON.stringify(data2)}\n\n`);\n }\n },\n prisma\n }),\n getMessages: getMessages({\n prisma,\n run: run4\n })\n });\n } catch (error) {\n console.error(error);\n onEvent({\n controller: {\n ...controller,\n enqueue: (data2) => {\n controller.enqueue(`data: ${JSON.stringify(data2)}\n\n`);\n }\n },\n prisma\n })({\n event: \"thread.run.failed\",\n data: {\n id: run4.id,\n failed_at: (0, import_dayjs7.default)().unix(),\n last_error: {\n code: \"server_error\",\n message: `${error?.message ?? \"\"} ${error?.cause?.message ?? \"\"}`\n }\n }\n });\n }\n controller.close();\n }\n });\n if (stream) {\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n return new Response(JSON.stringify(\n data\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/index.ts\nvar runs = ({\n prisma,\n runAdapter\n}) => ({\n get: get13({ prisma }),\n post: post13({ prisma, runAdapter })\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/run/get.ts\nvar get14 = ({\n prisma\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(runRegexp));\n const run4 = await prisma.run.findUnique({\n where: {\n id: runId,\n threadId\n }\n });\n if (!run4) {\n return new Response(JSON.stringify({ error: \"Not Found\" }), {\n status: 404,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n return new Response(JSON.stringify(\n serializeRun({ run: mapPrismaRun(run4) })\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\",\n \"openai-poll-after-ms\": \"5000\"\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/run/index.ts\nvar run = ({\n prisma,\n runAdapter\n}) => ({\n get: get14({ prisma })\n // post: post({ prisma, runAdapter }),\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/steps/get.ts\nvar import_radash14 = require(\"radash\");\nvar get15 = ({\n prisma\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(stepsRegexp));\n const {\n limit,\n order,\n after\n } = (0, import_radash14.assign)({\n limit: \"20\",\n order: \"desc\"\n // after: null,\n }, Object.fromEntries(url.searchParams));\n const pageSize = parseInt(limit, 10);\n const runStepsPlusOne = await prisma.runStep.findMany({\n where: { threadId, runId },\n take: pageSize + 1,\n orderBy: { createdAt: order },\n ...after && {\n skip: 1,\n cursor: { id: after }\n }\n });\n const runSteps = runStepsPlusOne.slice(0, pageSize);\n return new Response(JSON.stringify({\n data: runSteps.map((runStep) => serializeRunStep({ runStep })),\n has_more: runStepsPlusOne.length > pageSize,\n last_id: runSteps.at(-1)?.id ?? null\n }), {\n status: 200,\n headers: { \"Content-Type\": \"application/json\" }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/steps/index.ts\nvar steps = ({\n prisma\n}) => ({\n get: get15({ prisma })\n});\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/submitToolOutputs/post/updateRun.ts\nvar import_dayjs8 = __toESM(require(\"dayjs\"), 1);\nvar updateRun = async ({\n prisma,\n runId,\n threadId,\n onThreadRunStepCompleted = () => {\n },\n tool_outputs\n}) => (\n // @ts-expect-error prisma transaction typing is broken\n prisma.$transaction(async (prisma2) => {\n const runSteps = await prisma2.runStep.findMany({\n where: {\n threadId,\n runId,\n type: \"TOOL_CALLS\",\n status: \"IN_PROGRESS\"\n },\n orderBy: {\n createdAt: \"asc\"\n }\n });\n for (const runStep of runSteps) {\n const completedRunStep = await prisma2.runStep.update({\n where: {\n id: runStep.id\n },\n data: {\n status: \"COMPLETED\",\n completedAt: (0, import_dayjs8.default)().unix(),\n stepDetails: {\n type: \"tool_calls\",\n // @ts-ignore-next-line\n tool_calls: runStep.stepDetails.tool_calls.map((toolCall) => {\n const toolOutput = tool_outputs.find((output) => output.tool_call_id === toolCall.id) \|\| tool_outputs[0];\n if (!toolOutput) {\n console.dir({ toolOutput, runStep, tool_outputs, runSteps }, { depth: null });\n throw new Error(\"Tool output not found\");\n }\n return {\n id: toolCall.id,\n type: toolCall.type,\n function: {\n ...toolCall.function,\n output: toolOutput.output\n }\n };\n })\n }\n }\n });\n onThreadRunStepCompleted({\n runStep: completedRunStep\n });\n }\n return prisma2.run.update({\n where: {\n id: runId\n },\n data: {\n status: \"QUEUED\"\n }\n });\n })\n);\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/submitToolOutputs/post/index.ts\nvar post14 = ({\n prisma,\n runAdapter\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(submitToolOutputsRegexp));\n const body = JSON.parse(options.body);\n const {\n tool_outputs,\n stream\n } = body;\n if (stream) {\n const readableStream = new ReadableStream({\n async start(controller) {\n const run4 = await updateRun({\n prisma,\n runId,\n threadId,\n tool_outputs,\n onThreadRunStepCompleted: async ({ runStep }) => {\n controller.enqueue(`data: ${JSON.stringify({\n event: \"thread.run.step.completed\",\n data: serializeRunStep({ runStep })\n })}\n\n`);\n }\n });\n await runAdapter.handleRun({\n run: serializeRun({ run: run4 }),\n onEvent: onEvent({\n controller: {\n ...controller,\n enqueue: (data) => {\n controller.enqueue(`data: ${JSON.stringify(data)}\n\n`);\n }\n },\n prisma\n }),\n getMessages: getMessages({ prisma, run: run4 })\n });\n controller.close();\n }\n });\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n const run4 = await updateRun({\n prisma,\n runId,\n threadId,\n tool_outputs\n });\n await new Promise((resolve) => new ReadableStream({\n async start(controller) {\n await runAdapter.handleRun({\n run: serializeRun({ run: run4 }),\n onEvent: onEvent({\n controller: {\n ...controller,\n enqueue: (data) => {\n controller.enqueue(`data: ${JSON.stringify(data)}\n\n`);\n }\n },\n prisma\n }),\n getMessages: getMessages({ prisma, run: run4 })\n });\n controller.close();\n resolve(void 0);\n }\n }));\n return new Response(JSON.stringify(\n run4\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/storage/prismaStorageAdapter/threads/runs/submitToolOutputs/index.ts\nvar submitToolOutputs = ({\n prisma,\n runAdapter\n}) => ({\n post: post14({\n prisma,\n // @ts-ignore-next-line\n runAdapter\n })\n});\n\n// src/adapters/storage/prismaStorageAdapter/assistants/post.ts\nvar import_dayjs9 = __toESM(require(\"dayjs\"), 1);\nvar post15 = ({ prisma }) => async (_url, options) => {\n if (!options.body) {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const { model, instructions } = body;\n const assistant = await prisma.assistant.create({\n data: { modelSlug: model, instructions }\n });\n const data = {\n id: assistant.id,\n object: \"assistant\",\n created_at: (0, import_dayjs9.default)().unix(),\n name: null,\n description: null,\n model,\n instructions,\n tools: [],\n metadata: {}\n };\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/prismaStorageAdapter/assistants/index.ts\nvar assistants = ({ prisma }) => ({\n post: post15({ prisma })\n});\n\n// src/adapters/storage/prismaStorageAdapter/index.ts\nvar prismaStorageAdapter = ({\n prisma\n}) => ({ runAdapter }) => ({\n requestHandlers: {\n \"^/(?:v1/\|openai/)?assistants$\": assistants({ prisma }),\n \"^/(?:v1\|/?openai)/threads$\": threads({ prisma }),\n [messagesRegexp]: messages2({ prisma }),\n [runsRegexp]: runs({ prisma, runAdapter }),\n [runRegexp]: run({ prisma, runAdapter }),\n [stepsRegexp]: steps({ prisma }),\n [submitToolOutputsRegexp]: submitToolOutputs({ prisma, runAdapter })\n }\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/serializeThread.ts\nvar serializeThread2 = ({\n conversation\n}) => ({\n id: conversation.id,\n object: \"thread\",\n created_at: conversation.created_at,\n metadata: conversation.metadata,\n // TODO\n tool_resources: null\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/post.ts\nvar post16 = ({\n client,\n addAnnotations = false\n}) => async (_urlString, options) => {\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const messages5 = body.messages \|\| [];\n const metadata = body.metadata \|\| {};\n const conversation = await client.conversations.create({\n metadata,\n items: messages5.map((message) => {\n const contentType = message.role === \"user\" ? \"input_text\" : \"output_text\";\n let contentArray;\n if (typeof message.content === \"string\") {\n const contentItem = {\n type: contentType,\n text: message.content\n };\n if (addAnnotations) {\n contentItem.annotations = [];\n }\n contentArray = [contentItem];\n } else if (Array.isArray(message.content)) {\n contentArray = message.content.map((part) => {\n if (typeof part === \"string\") {\n const item2 = {\n type: contentType,\n text: part\n };\n if (addAnnotations) {\n item2.annotations = [];\n }\n return item2;\n }\n if (part.type === \"text\") {\n const item2 = {\n type: contentType,\n text: part.text\n };\n if (addAnnotations) {\n item2.annotations = [];\n }\n return item2;\n }\n if (part.type === \"image_file\") {\n return {\n type: \"input_image\",\n file_id: part.image_file.file_id,\n detail: part.image_file.detail ?? \"auto\"\n };\n }\n if (part.type === \"image_url\") {\n return {\n type: \"input_image\",\n image_url: part.image_url.url,\n detail: part.image_url.detail ?? \"auto\"\n };\n }\n const item = {\n type: contentType,\n text: \"\"\n };\n if (addAnnotations) {\n item.annotations = [];\n }\n return item;\n });\n } else {\n const contentItem = {\n type: contentType,\n text: \"\"\n };\n if (addAnnotations) {\n contentItem.annotations = [];\n }\n contentArray = [contentItem];\n }\n return {\n type: \"message\",\n role: message.role === \"user\" ? \"user\" : \"assistant\",\n content: contentArray\n };\n })\n });\n return new Response(JSON.stringify(\n serializeThread2({ conversation })\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/index.ts\nvar threads2 = ({\n client,\n addAnnotations = false\n}) => ({\n post: post16({ client, addAnnotations })\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/messages/post.ts\nvar import_dayjs10 = __toESM(require(\"dayjs\"), 1);\nvar import_radash16 = require(\"radash\");\n\n// src/lib/items/serializeItemAsMessage.ts\nvar import_radash15 = require(\"radash\");\nvar serializeContent2 = ({\n item\n}) => {\n if (item.type === \"message\") {\n return item.content.map((contentBlock) => {\n if (contentBlock.type === \"input_text\") {\n return {\n type: \"text\",\n text: {\n value: contentBlock.text,\n annotations: []\n }\n };\n } else if (contentBlock.type === \"output_text\") {\n return {\n type: \"text\",\n text: {\n value: contentBlock.text,\n annotations: []\n }\n };\n } else if (contentBlock.type === \"input_image\") {\n return {\n type: \"image_file\",\n image_file: {\n file_id: contentBlock.file_id,\n detail: \"auto\"\n }\n };\n }\n return null;\n }).filter(Boolean);\n } else if (item.type === \"image_generation_call\") {\n if (!item.result) return [];\n return [{\n type: \"image_url\",\n image_url: {\n // @ts-expect-error bad openai types\n url: `data:image/${item.output_format};base64,${item.result}`,\n detail: \"auto\"\n }\n }];\n } else {\n return [];\n }\n};\nvar serializeAttachments = ({\n item\n}) => {\n if (item.type !== \"message\") return [];\n const inputFiles = item.content.filter((contentBlock) => contentBlock.type === \"input_file\" && contentBlock.file_id);\n return inputFiles.map((inputFile) => ({\n file_id: inputFile.file_id\n }));\n};\nvar serializeMetadata = ({\n item\n}) => {\n if (item.type === \"image_generation_call\") {\n return {\n item: JSON.stringify({\n ...item,\n result: \"truncated\"\n })\n };\n }\n return {\n item: JSON.stringify(item)\n };\n};\nvar serializeItemAsMessage = ({\n item,\n threadId,\n openaiAssistant,\n createdAt,\n runId = null,\n status: status3 = \"completed\"\n}) => ({\n id: item.id \|\| (0, import_radash15.uid)(24),\n object: \"thread.message\",\n created_at: createdAt,\n thread_id: threadId,\n completed_at: null,\n incomplete_at: null,\n incomplete_details: null,\n role: typeof item.role === \"string\" ? item.role : \"assistant\",\n content: serializeContent2({ item }),\n assistant_id: item.role === \"assistant\" ? openaiAssistant.id : null,\n run_id: runId,\n attachments: serializeAttachments({ item }),\n status: typeof item.status === \"string\" ? item.status : status3,\n metadata: serializeMetadata({ item })\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/messages/post.ts\nvar contentBlocksFromContent = ({\n content,\n addAnnotations = false\n}) => {\n if ((0, import_radash16.isArray)(content)) {\n return content.map((item) => {\n if (item.type === \"text\") {\n const textItem3 = {\n type: \"input_text\",\n text: item.text\n };\n if (addAnnotations) {\n textItem3.annotations = [];\n }\n return textItem3;\n }\n if (item.type === \"image_file\") {\n return {\n type: \"input_image\",\n file_id: item.image_file.file_id,\n detail: item.image_file.detail ?? \"auto\"\n };\n }\n if (item.type === \"image_url\") {\n return {\n type: \"input_image\",\n image_url: item.image_url.url,\n detail: item.image_url.detail ?? \"auto\"\n };\n }\n const textItem2 = {\n type: \"input_text\",\n text: \"\"\n };\n if (addAnnotations) {\n textItem2.annotations = [];\n }\n return textItem2;\n });\n }\n const textItem = {\n type: \"input_text\",\n text: content ?? \"\"\n };\n if (addAnnotations) {\n textItem.annotations = [];\n }\n return [textItem];\n};\nvar contentBlocksFromAttachments = ({\n attachments\n}) => attachments.map((attachment) => ({\n type: \"input_file\",\n file_id: attachment.file_id\n}));\nvar messageContentBlocks2 = ({\n content,\n attachments,\n addAnnotations = false\n}) => [\n ...contentBlocksFromContent({ content, addAnnotations }),\n ...contentBlocksFromAttachments({ attachments })\n];\nvar post17 = ({\n runAdapter,\n createResponseItems,\n addAnnotations = false\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp));\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const { role, content, attachments = [] } = body;\n const item = {\n type: \"message\",\n role,\n content: messageContentBlocks2({\n content,\n attachments,\n addAnnotations\n })\n };\n createResponseItems.push(item);\n const openaiAssistant = await runAdapter.getOpenaiAssistant({ select: { id: true } });\n return new Response(JSON.stringify(\n serializeItemAsMessage({\n item,\n threadId,\n openaiAssistant,\n createdAt: (0, import_dayjs10.default)().unix()\n })\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/messages/get.ts\nvar import_radash17 = require(\"radash\");\n\n// src/lib/items/responseId.ts\nfunction responseId({\n conversation,\n itemId\n}) {\n if (!conversation.metadata) return null;\n const metadata = conversation.metadata;\n const keys = Object.keys(metadata).map((k) => {\n const m = /^responseItemsMap(\\d+)$/.exec(k);\n return m ? { key: k, idx: Number(m[1]) } : null;\n }).filter((x) => !!x).sort((a, b) => a.idx - b.idx);\n for (let i = keys.length - 1; i >= 0; i--) {\n const raw = metadata[keys[i].key];\n if (!raw \|\| raw === \"[]\") continue;\n let arr = [];\n try {\n arr = JSON.parse(raw);\n if (!Array.isArray(arr)) continue;\n } catch {\n continue;\n }\n for (let j = arr.length - 1; j >= 0; j--) {\n const entry = arr[j];\n if (entry?.itemIds?.includes(itemId)) {\n return entry.responseId \|\| null;\n }\n }\n }\n return null;\n}\n\n// src/adapters/storage/responsesStorageAdapter/threads/messages/get.ts\nvar get16 = ({\n client,\n runAdapter\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp));\n const {\n limit,\n order,\n after\n } = (0, import_radash17.assign)({\n limit: \"20\",\n order: \"desc\"\n // after: null,\n }, Object.fromEntries(url.searchParams));\n const conversation = await client.conversations.retrieve(threadId);\n const sortOrder = order === \"asc\" ? \"asc\" : \"desc\";\n const items = await client.conversations.items.list(threadId, {\n limit: parseInt(limit, 10),\n after,\n order: sortOrder\n });\n const itemsWithRunIds = mapItemsWithRunIds({ conversation, items: items.data });\n const responseMap = await fetchResponsesForItems({\n client,\n items: itemsWithRunIds\n });\n const timestampedItems = assignTimestamps({\n items: itemsWithRunIds,\n responseMap,\n sortOrder,\n conversationCreatedAt: conversation.created_at\n });\n const openaiAssistant = await runAdapter.getOpenaiAssistant({ select: { id: true } });\n return new Response(JSON.stringify({\n data: timestampedItems.map(({ item, runId, assignedTimestamp }) => serializeItemAsMessage({\n item,\n threadId,\n openaiAssistant,\n createdAt: assignedTimestamp,\n runId\n })),\n has_more: items.has_more,\n last_id: items.last_id\n }), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\nvar mapItemsWithRunIds = ({\n conversation,\n items\n}) => items.map((item) => ({\n item,\n runId: item.id ? responseId({\n conversation,\n itemId: item.id\n }) : null\n}));\nvar fetchResponsesForItems = async ({\n client,\n items\n}) => {\n const responseIds = Array.from(new Set(\n items.map(({ runId }) => runId).filter((id) => Boolean(id))\n ));\n const results = await Promise.allSettled(\n responseIds.map((id) => client.responses.retrieve(id))\n );\n const map = / @__PURE__ / new Map();\n results.forEach((result, index) => {\n if (result.status === \"fulfilled\") {\n map.set(responseIds[index], result.value);\n }\n });\n return map;\n};\nvar assignTimestamps = ({\n items,\n responseMap,\n sortOrder,\n conversationCreatedAt\n}) => {\n const itemsWithTimestamps = items.map((entry) => ({\n ...entry,\n timestamp: entry.runId ? responseMap.get(entry.runId)?.created_at ?? null : null,\n assignedTimestamp: 0\n }));\n const fallbackTimestampForIndex = (index) => sortOrder === \"asc\" ? conversationCreatedAt + index : conversationCreatedAt + (itemsWithTimestamps.length - index);\n const findNextKnownTimestamp = (startIndex) => {\n for (let i = startIndex; i < itemsWithTimestamps.length; i += 1) {\n const candidate = itemsWithTimestamps[i];\n if (candidate.timestamp != null) {\n return { index: i, timestamp: candidate.timestamp };\n }\n }\n return null;\n };\n if (sortOrder === \"asc\") {\n let lastAssigned = null;\n itemsWithTimestamps.forEach((entry, index) => {\n let nextValue = entry.timestamp;\n if (nextValue == null) {\n if (lastAssigned != null) {\n nextValue = lastAssigned + 1;\n } else {\n const nextKnown = findNextKnownTimestamp(index + 1);\n if (nextKnown) {\n const gap = nextKnown.index - index;\n nextValue = nextKnown.timestamp - gap;\n } else {\n nextValue = fallbackTimestampForIndex(index);\n }\n }\n }\n if (lastAssigned != null && nextValue <= lastAssigned) {\n nextValue = lastAssigned + 1;\n }\n entry.assignedTimestamp = nextValue;\n lastAssigned = nextValue;\n });\n } else {\n let lastAssigned = null;\n itemsWithTimestamps.forEach((entry, index) => {\n let nextValue = entry.timestamp;\n if (nextValue == null) {\n if (lastAssigned != null) {\n nextValue = lastAssigned - 1;\n } else {\n const nextKnown = findNextKnownTimestamp(index + 1);\n if (nextKnown) {\n const gap = nextKnown.index - index;\n nextValue = nextKnown.timestamp + gap;\n } else {\n nextValue = fallbackTimestampForIndex(index);\n }\n }\n }\n if (lastAssigned != null && nextValue >= lastAssigned) {\n nextValue = lastAssigned - 1;\n }\n entry.assignedTimestamp = nextValue;\n lastAssigned = nextValue;\n });\n }\n return itemsWithTimestamps;\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/messages/index.ts\nvar messages3 = ({\n client,\n runAdapter,\n createResponseItems,\n addAnnotations = false\n}) => ({\n post: post17({ runAdapter, createResponseItems, addAnnotations }),\n get: get16({ client, runAdapter })\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/get.ts\nvar get17 = () => async (urlString) => {\n return new Response(JSON.stringify({\n data: [],\n has_more: false,\n last_id: null\n }), {\n status: 200,\n headers: { \"Content-Type\": \"application/json\" }\n });\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/post.ts\nvar import_radash18 = require(\"radash\");\nvar import_dayjs11 = __toESM(require(\"dayjs\"), 1);\nvar import_radash19 = require(\"radash\");\n\n// src/lib/responses/serializeResponseAsRun.ts\nvar serializeStatus = ({\n response\n}) => {\n if (response.error) return \"failed\";\n return response.status?.toLowerCase() ?? \"completed\";\n};\nvar serializeUsage = ({\n response\n}) => ({\n prompt_tokens: response.usage?.input_tokens ?? 0,\n completion_tokens: response.usage?.output_tokens ?? 0,\n total_tokens: response.usage?.total_tokens ?? 0\n});\nvar findPendingToolCalls = ({\n response\n}) => {\n const toolCalls = (response.output ?? []).filter(\n (item) => item.type === \"function_call\"\n );\n if (toolCalls.length === 0) return [];\n const completedCallIds = new Set(\n (response.output ?? []).filter(\n (item) => (\n // @ts-expect-error missing openai type\n item.type === \"function_call_output\"\n )\n ).map((item) => (\n // @ts-expect-error missing openai type\n item.call_id\n )).filter((id) => Boolean(id))\n );\n return toolCalls.filter((call) => !completedCallIds.has(call.call_id));\n};\nvar serializeToolCalls = ({\n toolCalls\n}) => toolCalls.map((toolCall) => ({\n id: toolCall.call_id,\n type: \"function\",\n function: {\n name: toolCall.name,\n arguments: toolCall.arguments\n }\n}));\nvar serializeResponseAsRun = ({\n response,\n assistantId\n}) => {\n const pendingToolCalls = findPendingToolCalls({ response });\n const status3 = pendingToolCalls.length > 0 ? \"requires_action\" : serializeStatus({ response });\n return {\n id: response.id,\n object: \"thread.run\",\n created_at: response.created_at,\n thread_id: response.conversation.id,\n assistant_id: assistantId,\n status: status3,\n required_action: pendingToolCalls.length > 0 ? {\n type: \"submit_tool_outputs\",\n submit_tool_outputs: {\n tool_calls: serializeToolCalls({ toolCalls: pendingToolCalls })\n }\n } : null,\n last_error: response.error,\n expires_at: response.created_at,\n started_at: response.created_at,\n cancelled_at: null,\n failed_at: response.error ? response.created_at : null,\n completed_at: status3 === \"completed\" ? response.created_at : null,\n model: response.model,\n instructions: \"\",\n tools: [],\n metadata: response.metadata,\n usage: serializeUsage({ response }),\n truncation_strategy: {\n type: \"auto\"\n },\n response_format: {\n type: \"text\"\n },\n incomplete_details: null,\n max_completion_tokens: null,\n max_prompt_tokens: null,\n tool_choice: \"auto\",\n parallel_tool_calls: true\n };\n};\n\n// src/lib/responses/saveResponseItemsToConversationMetadata.ts\nvar BUCKET_PREFIX = \"responseItemsMap\";\nvar MAX_BUCKETS = 16;\nvar MAX_VALUE_LENGTH = 512;\nfunction parseBucket({ value }) {\n if (!value \|\| value === \"[]\") return [];\n try {\n const arr = JSON.parse(value);\n return Array.isArray(arr) ? arr : [];\n } catch {\n return [];\n }\n}\nfunction serializeBucket({ entries }) {\n return JSON.stringify(entries);\n}\nfunction bucketKey({ index }) {\n return `${BUCKET_PREFIX}${index}`;\n}\nfunction listBucketIndices({ metadata }) {\n return Object.keys(metadata).map((k) => {\n const m = new RegExp(`^${BUCKET_PREFIX}(\\\\d+)$`).exec(k);\n return m ? Number(m[1]) : -1;\n }).filter((i) => i >= 0).sort((a, b) => a - b);\n}\nfunction parseAllPairs({ metadata }) {\n const indices = listBucketIndices({ metadata });\n const pairs = [];\n for (const idx of indices) {\n const key = bucketKey({ index: idx });\n const entries = parseBucket({ value: metadata[key] });\n for (const e of entries) {\n for (const iid of e.itemIds) {\n pairs.push({ responseId: e.responseId, itemId: iid });\n }\n }\n }\n return pairs;\n}\nfunction serializeNonBucketEntries({ entries }) {\n const result = {};\n for (const [key, value] of entries) {\n result[key] = value;\n }\n return result;\n}\nfunction packIntoBuckets({ pairs, slots }) {\n const buckets = [];\n let currentEntries = [];\n const flush = () => {\n if (currentEntries.length === 0) return true;\n const serialized = serializeBucket({ entries: currentEntries });\n if (serialized.length > MAX_VALUE_LENGTH) return false;\n if (buckets.length >= slots) return false;\n buckets.push(serialized);\n currentEntries = [];\n return true;\n };\n for (const { responseId: responseId2, itemId } of pairs) {\n const candidateEntries = currentEntries.map((entry) => ({\n responseId: entry.responseId,\n itemIds: [...entry.itemIds]\n }));\n const last3 = candidateEntries.at(-1);\n if (last3 && last3.responseId === responseId2) {\n last3.itemIds.push(itemId);\n } else {\n candidateEntries.push({ responseId: responseId2, itemIds: [itemId] });\n }\n const serialized = serializeBucket({ entries: candidateEntries });\n if (serialized.length <= MAX_VALUE_LENGTH) {\n currentEntries = candidateEntries;\n continue;\n }\n if (!flush()) return void 0;\n currentEntries = [{ responseId: responseId2, itemIds: [itemId] }];\n if (serializeBucket({ entries: currentEntries }).length > MAX_VALUE_LENGTH) {\n return void 0;\n }\n }\n if (!flush()) return void 0;\n return buckets;\n}\nfunction metadataEquals(a, b) {\n const keysA = Object.keys(a);\n const keysB = Object.keys(b);\n if (keysA.length !== keysB.length) return false;\n for (const key of keysA) {\n if (!Object.prototype.hasOwnProperty.call(b, key)) return false;\n if (a[key] !== b[key]) return false;\n }\n return true;\n}\nfunction appendItemIdsToConversationMetadata({\n metadata,\n responseId: responseId2,\n itemIds\n}) {\n const base = { ...metadata \|\| {} };\n const nonBucketEntries = Object.entries(base).filter(([key]) => !key.startsWith(BUCKET_PREFIX));\n const availableSlots = Math.max(0, MAX_BUCKETS - nonBucketEntries.length);\n const preservedNonBucket = serializeNonBucketEntries({ entries: nonBucketEntries });\n if (availableSlots <= 0) {\n return { metadata: base, changed: false };\n }\n const existingPairs = parseAllPairs({ metadata: base });\n const incomingPairs = itemIds.map((id) => ({ responseId: responseId2, itemId: id }));\n const combinedPairs = existingPairs.concat(incomingPairs);\n let retainedOldestFirst = [];\n for (let idx = combinedPairs.length - 1; idx >= 0; idx -= 1) {\n const candidate = [combinedPairs[idx], ...retainedOldestFirst];\n const buckets2 = packIntoBuckets({ pairs: candidate, slots: availableSlots });\n if (buckets2) {\n retainedOldestFirst = candidate;\n }\n }\n const buckets = packIntoBuckets({ pairs: retainedOldestFirst, slots: availableSlots });\n if (!buckets) {\n const changed2 = !metadataEquals(base, preservedNonBucket);\n return { metadata: changed2 ? preservedNonBucket : base, changed: changed2 };\n }\n const rebuilt = { ...preservedNonBucket };\n buckets.forEach((value, index) => {\n if (value && value !== \"[]\") {\n rebuilt[bucketKey({ index })] = value;\n }\n });\n const changed = !metadataEquals(base, rebuilt);\n return { metadata: rebuilt, changed };\n}\nasync function saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId: responseId2,\n itemIds\n}) {\n const conversation = await client.conversations.retrieve(threadId);\n const { metadata: updated, changed } = appendItemIdsToConversationMetadata({\n metadata: conversation.metadata,\n responseId: responseId2,\n itemIds\n });\n if (!changed) return;\n await client.conversations.update(threadId, { metadata: updated });\n}\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/shared.ts\nvar serializeTools3 = ({\n tools\n}) => {\n if (!tools?.length) return {};\n return {\n tools: tools.map((tool) => ({\n type: tool.type,\n // @ts-ignore-next-line\n ...tool[tool.type] \|\| {}\n }))\n };\n};\nvar truncation = ({\n truncation_strategy\n}) => {\n if (truncation_strategy.type === \"disabled\") {\n return \"disabled\";\n }\n return \"auto\";\n};\nvar textConfig = ({\n response_format\n}) => {\n if (response_format && typeof response_format === \"object\") {\n return {\n format: response_format\n };\n }\n return void 0;\n};\nvar defaultAssistant = {\n model: \"\",\n instructions: \"\",\n additional_instructions: null,\n truncation_strategy: {\n type: \"auto\"\n },\n response_format: {\n type: \"text\"\n }\n // tools: [],\n // metadata: {},\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/post.ts\nvar post18 = ({\n client,\n runAdapter,\n createResponseItems\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp));\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const {\n assistant_id,\n stream\n } = body;\n const openaiAssistant = await runAdapter.getOpenaiAssistant();\n const {\n model,\n instructions,\n // additional_instructions,\n tools,\n metadata,\n response_format,\n truncation_strategy\n } = (0, import_radash19.assign)({\n ...defaultAssistant,\n ...openaiAssistant\n }, body);\n const shouldSendInstructions = typeof instructions === \"string\" && instructions.trim().length > 0;\n const responseBody = {\n conversation: threadId,\n stream,\n input: createResponseItems\n };\n responseBody.model = model;\n responseBody.metadata = metadata;\n Object.assign(responseBody, serializeTools3({ tools }));\n responseBody.truncation = truncation({ truncation_strategy });\n const normalizedText = textConfig({ response_format });\n if (normalizedText) {\n responseBody.text = normalizedText;\n }\n if (shouldSendInstructions && typeof instructions === \"string\") {\n responseBody.instructions = instructions;\n }\n const response = await client.responses.create(responseBody);\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => controller.enqueue(`data: ${JSON.stringify(event)}\n\n`)\n });\n } catch (error) {\n console.error(error);\n const event = {\n event: \"thread.run.failed\",\n data: {\n id: (0, import_radash18.uid)(24),\n failed_at: (0, import_dayjs11.default)().unix(),\n last_error: {\n code: \"server_error\",\n message: `${error?.message ?? \"\"} ${error?.cause?.message ?? \"\"}`\n }\n }\n };\n controller.enqueue(`data: ${JSON.stringify(event)}\n\n`);\n }\n controller.close();\n }\n });\n if (stream) {\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n const nonStreamResponse = response;\n const itemIds = (nonStreamResponse.output ?? []).filter((o) => o.id).map((o) => o.id);\n if (itemIds.length > 0) {\n await saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId: nonStreamResponse.id,\n itemIds\n });\n }\n const data = serializeResponseAsRun({\n response: nonStreamResponse,\n assistantId: assistant_id\n });\n return new Response(JSON.stringify(\n data\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/index.ts\nvar runs2 = ({\n client,\n runAdapter,\n createResponseItems\n}) => ({\n get: get17(),\n post: post18({ client, createResponseItems, runAdapter })\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/run/get.ts\nvar get18 = ({\n client,\n runAdapter\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, _threadId, runId] = url.pathname.match(new RegExp(runRegexp));\n const response = await client.responses.retrieve(runId);\n const data = serializeResponseAsRun({\n response,\n assistantId: (await runAdapter.getOpenaiAssistant({ select: { id: true } })).id\n });\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\",\n \"openai-poll-after-ms\": \"5000\"\n }\n });\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/run/index.ts\nvar run2 = ({\n client,\n runAdapter\n}) => ({\n get: get18({ client, runAdapter })\n // post: post({ prisma, runAdapter }),\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/steps/get.ts\nvar import_radash23 = require(\"radash\");\n\n// src/lib/items/serializeItemAsMessageCreationRunStep.ts\nvar import_dayjs12 = __toESM(require(\"dayjs\"), 1);\nvar import_radash20 = require(\"radash\");\nfunction serializeItemAsMessageCreationRunStep({\n item,\n threadId,\n openaiAssistant,\n runId = `run_${(0, import_radash20.uid)(24)}`,\n status: status3 = \"completed\",\n completedAt = (0, import_dayjs12.default)().unix()\n}) {\n const itemId = typeof item.id === \"string\" ? item.id : `item_${(0, import_radash20.uid)(18)}`;\n const base = {\n id: itemId,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs12.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: status3,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null\n };\n if (item.type === \"message\") {\n return {\n ...base,\n type: \"message_creation\",\n step_details: {\n type: \"message_creation\",\n message_creation: {\n // If you also create a thread.message elsewhere, substitute that id here.\n message_id: itemId\n // <- always string\n }\n },\n // keep role if present (assistant/user/system), optional\n metadata: \"role\" in item ? { role: item.role } : {}\n };\n } else if (item.type === \"image_generation_call\") {\n return {\n ...base,\n type: \"message_creation\",\n step_details: {\n type: \"message_creation\",\n message_creation: { message_id: itemId }\n },\n metadata: {\n item: JSON.stringify({\n ...item,\n result: \"truncated\"\n })\n }\n };\n }\n return {\n ...base,\n type: \"message_creation\",\n step_details: {\n type: \"message_creation\",\n message_creation: { message_id: itemId }\n },\n metadata: {\n item: JSON.stringify(item)\n }\n };\n}\n\n// src/lib/items/serializeItemAsFunctionCallRunStep.ts\nvar import_dayjs13 = __toESM(require(\"dayjs\"), 1);\nvar import_radash21 = require(\"radash\");\nvar serializeFunctionCallOutput = ({\n functionCallOutput\n}) => {\n if (!functionCallOutput) return null;\n if (typeof functionCallOutput.output === \"string\") {\n return functionCallOutput.output;\n }\n return JSON.stringify(functionCallOutput.output);\n};\nvar serializeItemAsFunctionCallRunStep = ({\n item,\n items,\n threadId,\n openaiAssistant,\n runId = `run_${(0, import_radash21.uid)(24)}`,\n status: status3 = \"completed\",\n completedAt = (0, import_dayjs13.default)().unix()\n}) => {\n const itemId = typeof item.id === \"string\" ? item.id : `item_${(0, import_radash21.uid)(18)}`;\n const base = {\n id: itemId,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs13.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: status3,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null\n };\n const functionCallOutput = items.find((i) => i.type === \"function_call_output\" && i.call_id === item.call_id);\n const toolCall = {\n id: item.call_id,\n type: \"function\",\n function: {\n name: item.name,\n arguments: item.arguments,\n output: serializeFunctionCallOutput({ functionCallOutput })\n }\n };\n return {\n ...base,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/lib/items/serializeItemAsImageGenerationRunStep.ts\nvar import_dayjs14 = __toESM(require(\"dayjs\"), 1);\nvar serializeStatus2 = ({\n item\n}) => {\n if (item.result !== null) {\n return \"completed\";\n }\n if (item.status === \"generating\") {\n return \"in_progress\";\n }\n return item.status;\n};\nvar serializeItemAsImageGenerationRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = (0, import_dayjs14.default)().unix(),\n status: status3 = serializeStatus2({ item })\n}) => {\n const toolCall = {\n id: `ftc${item.id}`,\n type: \"function\",\n function: {\n name: \"image_generation\",\n arguments: \"{}\",\n output: JSON.stringify({\n status: item.status,\n // @ts-expect-error bad openai types\n background: item.background,\n // @ts-expect-error bad openai types\n output_format: item.output_format,\n // @ts-expect-error bad openai types\n quality: item.quality,\n result: item.result,\n // @ts-expect-error bad openai types\n size: item.size,\n // @ts-expect-error bad openai types\n revised_prompt: item.revised_prompt\n })\n }\n };\n return {\n id: `fc${item.id}`,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs14.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: status3,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/lib/items/serializeItemAsWebSearchRunStep.ts\nvar import_dayjs15 = __toESM(require(\"dayjs\"), 1);\nvar serializeStatus3 = ({\n item\n}) => {\n if (item.status === \"searching\") {\n return \"in_progress\";\n }\n return item.status;\n};\nvar serializeItemAsWebSearchRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = (0, import_dayjs15.default)().unix()\n}) => {\n const toolCall = {\n id: `ftc${item.id}`,\n type: \"function\",\n function: {\n name: \"web_search\",\n arguments: JSON.stringify({\n // @ts-expect-error bad openai types\n action: item.action\n }),\n output: JSON.stringify({\n status: item.status\n })\n }\n };\n return {\n id: `fc${item.id}`,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs15.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus3({ item }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/lib/items/serializeItemAsMcpListToolsRunStep.ts\nvar import_dayjs16 = __toESM(require(\"dayjs\"), 1);\nvar serializeStatus4 = ({\n item\n}) => {\n if (item.error) {\n return \"failed\";\n }\n return \"completed\";\n};\nvar serializeItemAsMcpListToolsRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = (0, import_dayjs16.default)().unix()\n}) => {\n const toolCall = {\n id: `ftc${item.id}`,\n type: \"function\",\n function: {\n name: \"mcp_list_tools\",\n arguments: JSON.stringify({\n server_label: item.server_label\n }),\n output: JSON.stringify({\n tools: item.tools,\n ...item.error && { error: item.error }\n })\n }\n };\n return {\n id: `fc${item.id}`,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs16.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus4({ item }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/lib/items/serializeItemAsMcpCallRunStep.ts\nvar import_dayjs17 = __toESM(require(\"dayjs\"), 1);\nvar serializeStatus5 = ({\n item\n}) => {\n if (item.error) {\n return \"failed\";\n }\n return \"completed\";\n};\nvar serializeItemAsMcpCallRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = (0, import_dayjs17.default)().unix()\n}) => {\n const toolCall = {\n id: `ftc${item.id}`,\n type: \"function\",\n function: {\n name: item.name,\n arguments: item.arguments,\n // @ts-expect-error compat\n server_label: item.server_label,\n output: item.output ?? item.error ?? null\n }\n };\n return {\n id: `fc${item.id}`,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs17.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus5({ item }),\n last_error: item.error ? { code: \"server_error\", message: item.error } : null,\n expired_at: null,\n cancelled_at: null,\n failed_at: item.error ? (0, import_dayjs17.default)().unix() : null,\n completed_at: item.error ? null : completedAt,\n metadata: {},\n usage: null,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/lib/items/serializeItemAsCodeInterpreterCallRunStep.ts\nvar import_dayjs18 = __toESM(require(\"dayjs\"), 1);\nvar serializeStatus6 = ({\n item\n}) => {\n if (item.status === \"incomplete\") {\n return \"in_progress\";\n } else if (item.status === \"interpreting\") {\n return \"in_progress\";\n }\n return item.status;\n};\nvar serializeOutput = ({\n output\n}) => {\n return {\n type: output.type,\n logs: output.logs\n };\n};\nvar serializeOutputs = ({\n item\n}) => {\n if (!item.outputs) return [];\n return item.outputs.filter((o) => o.type === \"logs\").map((output) => serializeOutput({ output }));\n};\nvar serializeItemAsCodeInterpreterCallRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = (0, import_dayjs18.default)().unix()\n}) => {\n const toolCall = {\n id: `citc${item.id}`,\n type: \"code_interpreter\",\n code_interpreter: {\n input: item.code ?? \"\",\n outputs: serializeOutputs({ item })\n }\n };\n return {\n id: `fc${item.id}`,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs18.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus6({ item }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {\n item: JSON.stringify(item)\n },\n usage: null,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/lib/items/serializeItemAsComputerCallRunStep.ts\nvar import_dayjs19 = __toESM(require(\"dayjs\"), 1);\nvar import_radash22 = require(\"radash\");\nvar serializeItemAsComputerCallRunStep = ({\n item,\n items,\n threadId,\n openaiAssistant,\n runId = `run_${(0, import_radash22.uid)(24)}`,\n status: status3 = \"completed\",\n completedAt = (0, import_dayjs19.default)().unix()\n}) => {\n const itemId = typeof item.id === \"string\" ? item.id : `item_${(0, import_radash22.uid)(18)}`;\n const base = {\n id: itemId,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs19.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: status3,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null\n };\n const computerCallOutput2 = items.find((i) => i.type === \"computer_call_output\" && i.call_id === item.call_id);\n const toolCall = {\n id: item.call_id,\n type: \"function\",\n function: {\n name: \"computer_call\",\n arguments: JSON.stringify({\n action: item.action,\n pending_safety_checks: item.pending_safety_checks\n }),\n output: computerCallOutput2 ? JSON.stringify(computerCallOutput2.output) : null\n }\n };\n return {\n ...base,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/lib/items/serializeItemAsReasoningRunStep.ts\nvar import_dayjs20 = __toESM(require(\"dayjs\"), 1);\nvar serializeStatus7 = ({\n item,\n completedAt\n}) => {\n if (!item.status) {\n if (completedAt) {\n return \"completed\";\n } else {\n return \"in_progress\";\n }\n }\n if (item.status === \"incomplete\") {\n return \"in_progress\";\n }\n return item.status;\n};\nvar serializeItemAsReasoningRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = (0, import_dayjs20.default)().unix()\n}) => {\n const toolCall = {\n id: `ftc${item.id}`,\n type: \"function\",\n function: {\n name: \"reasoning\",\n arguments: \"{}\",\n output: JSON.stringify({\n summary: item.summary,\n content: item.content,\n encrypted_content: item.encrypted_content\n })\n }\n };\n return {\n id: `fc${item.id}`,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs20.default)().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus7({ item, completedAt }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: \"tool_calls\",\n step_details: {\n type: \"tool_calls\",\n tool_calls: [toolCall]\n }\n };\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/steps/get.ts\nvar get19 = ({\n client,\n runAdapter\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(stepsRegexp));\n const response = await client.responses.retrieve(runId);\n const latestToolCallItem = response.output.findLast((item) => item.type === \"function_call\");\n let functionCallOutputItems = [];\n let computerCallOutputItems = [];\n if (latestToolCallItem) {\n const items = await client.conversations.items.list(threadId, {\n after: latestToolCallItem.id,\n order: \"asc\",\n limit: 20\n });\n functionCallOutputItems = items.data.filter((item) => item.type === \"function_call_output\");\n computerCallOutputItems = items.data.filter((item) => item.type === \"computer_call_output\");\n }\n const openaiAssistant = await runAdapter.getOpenaiAssistant({ select: { id: true } });\n const data = response.output.flatMap((item) => {\n const step = serializeItemAsMessageCreationRunStep({\n item,\n threadId,\n openaiAssistant,\n runId: response.id\n });\n if (item.type === \"function_call\") {\n return [\n serializeItemAsFunctionCallRunStep({\n item,\n items: functionCallOutputItems,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n } else if (item.type === \"computer_call\") {\n return [\n serializeItemAsComputerCallRunStep({\n item,\n items: computerCallOutputItems,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n } else if (item.type === \"reasoning\") {\n return [\n serializeItemAsReasoningRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n } else if (item.type === \"image_generation_call\") {\n return [\n serializeItemAsImageGenerationRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n } else if (item.type === \"web_search_call\") {\n return [\n serializeItemAsWebSearchRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n } else if (item.type === \"mcp_list_tools\") {\n return [\n serializeItemAsMcpListToolsRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n } else if (item.type === \"mcp_call\") {\n return [\n serializeItemAsMcpCallRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n } else if (item.type === \"code_interpreter_call\") {\n return [\n serializeItemAsCodeInterpreterCallRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id\n }),\n step\n ];\n }\n return [step];\n });\n return new Response(JSON.stringify({\n data,\n has_more: false,\n last_id: (0, import_radash23.last)(response.output)?.id ?? null\n }), {\n status: 200,\n headers: { \"Content-Type\": \"application/json\" }\n });\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/steps/index.ts\nvar steps2 = ({\n client,\n runAdapter\n}) => ({\n get: get19({ client, runAdapter })\n});\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/submitToolOutputs/shared.ts\nvar computerCallOutput = ({\n toolOutput\n}) => {\n if (typeof toolOutput.output !== \"string\") return { isComputerCallOutput: false };\n let parsedOutput;\n try {\n parsedOutput = JSON.parse(toolOutput.output);\n } catch {\n return { isComputerCallOutput: false };\n }\n if (typeof parsedOutput !== \"object\" \|\| parsedOutput === null) return { isComputerCallOutput: false };\n if (parsedOutput.type !== \"computer_screenshot\") return { isComputerCallOutput: false };\n return {\n isComputerCallOutput: true,\n parsedOutput\n };\n};\nvar getToolCallOutputItems = ({\n tool_outputs\n}) => {\n const functionCallOutputItems = [];\n const computerCallOutputItems = [];\n tool_outputs.forEach((toolOutput) => {\n const { isComputerCallOutput, parsedOutput } = computerCallOutput({ toolOutput });\n if (isComputerCallOutput) {\n computerCallOutputItems.push({\n type: \"computer_call_output\",\n call_id: toolOutput.tool_call_id,\n output: parsedOutput,\n // @ts-expect-error compat\n acknowledged_safety_checks: toolOutput.acknowledged_safety_checks ?? []\n });\n } else {\n functionCallOutputItems.push({\n type: \"function_call_output\",\n call_id: toolOutput.tool_call_id,\n output: toolOutput.output ?? \"\"\n });\n }\n });\n return {\n functionCallOutputItems,\n computerCallOutputItems\n };\n};\nvar serializeTools4 = ({\n tools\n}) => {\n if (!tools?.length) return {};\n return {\n tools: tools.map((tool) => ({\n type: tool.type,\n // @ts-ignore-next-line\n ...tool[tool.type] \|\| {}\n }))\n };\n};\nvar truncation2 = ({\n openaiAssistant\n}) => {\n if (openaiAssistant.truncation_strategy?.type === \"disabled\") {\n return \"disabled\";\n }\n return \"auto\";\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/submitToolOutputs/post/index.ts\nvar post19 = ({\n client,\n runAdapter\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(submitToolOutputsRegexp));\n const body = JSON.parse(options.body);\n const {\n tool_outputs,\n stream\n } = body;\n const toolCallOutputItems = getToolCallOutputItems({ tool_outputs });\n const input = [...toolCallOutputItems.functionCallOutputItems, ...toolCallOutputItems.computerCallOutputItems];\n const previousResponse = await client.responses.retrieve(runId);\n const openaiAssistant = await runAdapter.getOpenaiAssistant();\n const shouldSendInstructions = typeof openaiAssistant.instructions === \"string\" && openaiAssistant.instructions.trim().length > 0;\n const responseBody = {\n conversation: threadId,\n stream,\n input\n };\n responseBody.model = openaiAssistant.model;\n Object.assign(responseBody, serializeTools4({ tools: openaiAssistant.tools }));\n responseBody.truncation = truncation2({ openaiAssistant });\n if (shouldSendInstructions && typeof openaiAssistant.instructions === \"string\") {\n responseBody.instructions = openaiAssistant.instructions;\n }\n const response = await client.responses.create(responseBody);\n const readableStream = new ReadableStream({\n async start(controller) {\n toolCallOutputItems.functionCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => i.type === \"function_call\" && i.call_id === item.call_id);\n if (!toolCallItem) {\n return;\n }\n controller.enqueue(`data: ${JSON.stringify({\n event: \"thread.run.step.completed\",\n data: serializeItemAsFunctionCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.functionCallOutputItems,\n threadId,\n openaiAssistant,\n runId\n })\n })}\n\n`);\n });\n toolCallOutputItems.computerCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => i.type === \"computer_call\" && i.call_id === item.call_id);\n if (!toolCallItem) {\n return;\n }\n controller.enqueue(`data: ${JSON.stringify({\n event: \"thread.run.step.completed\",\n data: serializeItemAsComputerCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.computerCallOutputItems,\n threadId,\n openaiAssistant,\n runId\n })\n })}\n\n`);\n });\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => controller.enqueue(`data: ${JSON.stringify(event)}\n\n`)\n });\n controller.close();\n }\n });\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n};\n\n// src/adapters/storage/responsesStorageAdapter/threads/runs/submitToolOutputs/index.ts\nvar submitToolOutputs2 = ({\n client,\n runAdapter\n}) => ({\n post: post19({\n client,\n runAdapter\n })\n});\n\n// src/adapters/storage/responsesStorageAdapter/assistants/get.ts\nvar get20 = ({\n runAdapter\n}) => async (_urlString) => {\n return new Response(JSON.stringify({\n data: [await runAdapter.getOpenaiAssistant()],\n has_more: false,\n last_id: (await runAdapter.getOpenaiAssistant({ select: { id: true } })).id\n }), {\n status: 200,\n headers: { \"Content-Type\": \"application/json\" }\n });\n};\n\n// src/adapters/storage/responsesStorageAdapter/assistants/post.ts\nvar post20 = () => async () => new Response(\n JSON.stringify({\n error: {\n message: \"Assistant creation is not implemented for the Responses storage adapter.\",\n type: \"not_implemented\"\n }\n }),\n {\n status: 501,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n }\n);\n\n// src/adapters/storage/responsesStorageAdapter/assistants/index.ts\nvar assistants2 = ({\n runAdapter\n}) => ({\n get: get20({ runAdapter }),\n post: post20()\n});\n\n// src/adapters/storage/responsesStorageAdapter/index.ts\nvar responsesStorageAdapter = () => {\n const createResponseItems = [];\n return ({ runAdapter, client }) => ({\n requestHandlers: {\n \"^/(?:v1\|/?openai)/assistants$\": assistants2({ runAdapter }),\n \"^/(?:v1\|/?openai)/threads$\": threads2({ client }),\n [messagesRegexp]: messages3({ client, runAdapter, createResponseItems }),\n [runsRegexp]: runs2({ client, runAdapter, createResponseItems }),\n [runRegexp]: run2({ client, runAdapter }),\n [stepsRegexp]: steps2({ client, runAdapter }),\n [submitToolOutputsRegexp]: submitToolOutputs2({ client, runAdapter })\n }\n });\n};\n\n// src/lib/responses/responseRegexp.ts\nvar responseRegexp = \"^/(?:v1\|/?openai)/responses/([^/]+)$\";\n\n// src/adapters/storage/azureResponsesStorageAdapter/threads/runs/post.ts\nvar import_radash24 = require(\"radash\");\nvar import_dayjs21 = __toESM(require(\"dayjs\"), 1);\nvar import_radash25 = require(\"radash\");\nvar post21 = ({\n client,\n runAdapter,\n createResponseItems\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp));\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const {\n assistant_id,\n stream\n } = body;\n const assistantId = typeof assistant_id === \"string\" ? assistant_id.trim() : \"\";\n const openaiAssistant = await runAdapter.getOpenaiAssistant();\n const {\n model,\n instructions,\n // additional_instructions,\n tools,\n metadata,\n response_format,\n truncation_strategy\n } = (0, import_radash25.assign)({\n ...defaultAssistant,\n ...openaiAssistant\n }, body);\n const azureAgentId = openaiAssistant && typeof openaiAssistant === \"object\" && typeof openaiAssistant.id === \"string\" && typeof openaiAssistant.name === \"string\" && openaiAssistant.id.trim().length > 0 && openaiAssistant.id === openaiAssistant.name && openaiAssistant.id === assistantId ? openaiAssistant.id : void 0;\n const shouldSendInstructions = !azureAgentId && typeof instructions === \"string\" && instructions.trim().length > 0;\n const responseBody = {\n conversation: threadId,\n stream,\n input: createResponseItems\n };\n if (azureAgentId) {\n responseBody.agent = {\n name: azureAgentId,\n type: \"agent_reference\"\n };\n }\n if (!azureAgentId) {\n responseBody.model = model;\n responseBody.metadata = metadata;\n Object.assign(responseBody, serializeTools3({ tools }));\n responseBody.truncation = truncation({ truncation_strategy });\n const normalizedText = textConfig({ response_format });\n if (normalizedText) {\n responseBody.text = normalizedText;\n }\n } else if (metadata && Object.keys(metadata).length > 0) {\n responseBody.metadata = metadata;\n }\n if (shouldSendInstructions && typeof instructions === \"string\") {\n responseBody.instructions = instructions;\n }\n const response = await client.responses.create(responseBody);\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => controller.enqueue(`data: ${JSON.stringify(event)}\n\n`)\n });\n } catch (error) {\n console.error(error);\n const event = {\n event: \"thread.run.failed\",\n data: {\n id: (0, import_radash24.uid)(24),\n failed_at: (0, import_dayjs21.default)().unix(),\n last_error: {\n code: \"server_error\",\n message: `${error?.message ?? \"\"} ${error?.cause?.message ?? \"\"}`\n }\n }\n };\n controller.enqueue(`data: ${JSON.stringify(event)}\n\n`);\n }\n controller.close();\n }\n });\n if (stream) {\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n const nonStreamResponse = response;\n const itemIds = (nonStreamResponse.output ?? []).filter((o) => o.id).map((o) => o.id);\n if (itemIds.length > 0) {\n await saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId: nonStreamResponse.id,\n itemIds\n });\n }\n const data = serializeResponseAsRun({\n response: nonStreamResponse,\n assistantId: assistant_id\n });\n return new Response(JSON.stringify(\n data\n ), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/storage/azureResponsesStorageAdapter/threads/runs/index.ts\nvar runs3 = ({\n client,\n runAdapter,\n createResponseItems\n}) => ({\n get: get17(),\n post: post21({ client, createResponseItems, runAdapter })\n});\n\n// src/adapters/storage/azureResponsesStorageAdapter/threads/runs/submitToolOutputs/post/index.ts\nvar post22 = ({\n client,\n runAdapter\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(submitToolOutputsRegexp));\n const body = JSON.parse(options.body);\n const {\n tool_outputs,\n stream\n } = body;\n const toolCallOutputItems = getToolCallOutputItems({ tool_outputs });\n const input = [...toolCallOutputItems.functionCallOutputItems, ...toolCallOutputItems.computerCallOutputItems];\n const previousResponse = await client.responses.retrieve(runId);\n const openaiAssistant = await runAdapter.getOpenaiAssistant();\n const azureAgentId = openaiAssistant && typeof openaiAssistant === \"object\" && typeof openaiAssistant.id === \"string\" && typeof openaiAssistant.name === \"string\" && openaiAssistant.id.trim().length > 0 && openaiAssistant.id === openaiAssistant.name ? openaiAssistant.id : void 0;\n const shouldSendInstructions = !azureAgentId && typeof openaiAssistant.instructions === \"string\" && openaiAssistant.instructions.trim().length > 0;\n const responseBody = {\n conversation: threadId,\n stream,\n input\n };\n if (azureAgentId) {\n responseBody.agent = {\n name: azureAgentId,\n type: \"agent_reference\"\n };\n }\n if (!azureAgentId) {\n responseBody.model = openaiAssistant.model;\n Object.assign(responseBody, serializeTools4({ tools: openaiAssistant.tools }));\n responseBody.truncation = truncation2({ openaiAssistant });\n }\n if (shouldSendInstructions && typeof openaiAssistant.instructions === \"string\") {\n responseBody.instructions = openaiAssistant.instructions;\n }\n const response = await client.responses.create(responseBody);\n const readableStream = new ReadableStream({\n async start(controller) {\n toolCallOutputItems.functionCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => i.type === \"function_call\" && i.call_id === item.call_id);\n if (!toolCallItem) {\n return;\n }\n controller.enqueue(`data: ${JSON.stringify({\n event: \"thread.run.step.completed\",\n data: serializeItemAsFunctionCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.functionCallOutputItems,\n threadId,\n openaiAssistant,\n runId\n })\n })}\n\n`);\n });\n toolCallOutputItems.computerCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => i.type === \"computer_call\" && i.call_id === item.call_id);\n if (!toolCallItem) {\n return;\n }\n controller.enqueue(`data: ${JSON.stringify({\n event: \"thread.run.step.completed\",\n data: serializeItemAsComputerCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.computerCallOutputItems,\n threadId,\n openaiAssistant,\n runId\n })\n })}\n\n`);\n });\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => controller.enqueue(`data: ${JSON.stringify(event)}\n\n`)\n });\n controller.close();\n }\n });\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n};\n\n// src/adapters/storage/azureResponsesStorageAdapter/threads/runs/submitToolOutputs/index.ts\nvar submitToolOutputs3 = ({\n client,\n runAdapter\n}) => ({\n post: post22({\n client,\n runAdapter\n })\n});\n\n// src/adapters/storage/azureResponsesStorageAdapter/responses/get.ts\nvar get21 = ({\n client\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, responseId2] = url.pathname.match(new RegExp(responseRegexp));\n const response = await client.responses.retrieve(responseId2);\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureResponsesStorageAdapter/responses/index.ts\nvar responses = ({\n client\n}) => ({\n get: get21({ client })\n});\n\n// src/adapters/storage/azureResponsesStorageAdapter/index.ts\nvar azureResponsesStorageAdapter = () => {\n const createResponseItems = [];\n let cachedClient = null;\n return ({ runAdapter, client, originalClient }) => {\n const getAIProjectClient = () => {\n if (originalClient && typeof originalClient === \"object\" && \"client\" in originalClient) {\n return originalClient.client;\n }\n return client;\n };\n const getAzureClient = async () => {\n if (cachedClient) {\n return cachedClient;\n }\n const aiProjectClient = getAIProjectClient();\n const apiVersion = typeof aiProjectClient === \"object\" ? aiProjectClient._options?.apiVersion : void 0;\n if (aiProjectClient && typeof aiProjectClient === \"object\" && \"getAzureOpenAIClient\" in aiProjectClient && typeof aiProjectClient.getAzureOpenAIClient === \"function\") {\n const azureClient = await aiProjectClient.getAzureOpenAIClient(\n apiVersion ? { apiVersion } : void 0\n );\n cachedClient = azureClient;\n return azureClient;\n }\n if (aiProjectClient && typeof aiProjectClient === \"object\" && \"getOpenAIClient\" in aiProjectClient && typeof aiProjectClient.getOpenAIClient === \"function\") {\n const azureClient = await aiProjectClient.getOpenAIClient(\n apiVersion ? { apiVersion } : void 0\n );\n cachedClient = azureClient;\n return azureClient;\n }\n cachedClient = aiProjectClient;\n return aiProjectClient;\n };\n const wrappedRunAdapter = {\n ...runAdapter,\n getOpenaiAssistant: runAdapter.getOpenaiAssistant,\n handleRun: async (args) => {\n const azureClient = await getAzureClient();\n return runAdapter.handleRun({ ...args, client: azureClient });\n }\n };\n const wrapHandlerMethod = (handlerFactory, method) => {\n return async (urlString, options) => {\n const openaiClient = await getAzureClient();\n const handler = handlerFactory({ client: openaiClient, runAdapter: wrappedRunAdapter, createResponseItems });\n return handler[method](urlString, options);\n };\n };\n const createWrappedHandlers = (handlerFactory, methods, additionalArgs = {}) => {\n const wrapped = {};\n for (const method of methods) {\n wrapped[method] = async (urlString, options) => {\n const azureClient = await getAzureClient();\n const handler = handlerFactory({\n client: azureClient,\n // Real Azure client with proper auth\n runAdapter: wrappedRunAdapter,\n createResponseItems,\n ...additionalArgs\n });\n return handler[method](urlString, options);\n };\n }\n return wrapped;\n };\n return {\n requestHandlers: {\n \"^/(?:v1\|/?openai)/assistants$\": assistants2({ runAdapter: wrappedRunAdapter }),\n \"^/(?:v1\|/?openai)/threads$\": createWrappedHandlers(threads2, [\"post\"], { addAnnotations: true }),\n [messagesRegexp]: createWrappedHandlers(messages3, [\"get\", \"post\"]),\n [runsRegexp]: createWrappedHandlers(runs3, [\"get\", \"post\"]),\n // Added GET for runs.list()\n [runRegexp]: createWrappedHandlers(run2, [\"get\"]),\n [stepsRegexp]: createWrappedHandlers(steps2, [\"get\"]),\n [submitToolOutputsRegexp]: createWrappedHandlers(submitToolOutputs3, [\"post\"]),\n [responseRegexp]: createWrappedHandlers(responses, [\"get\"])\n }\n };\n };\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/post.ts\nvar import_dayjs22 = __toESM(require(\"dayjs\"), 1);\nvar post23 = ({ azureAiProject }) => async (_urlString, options) => {\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const metadata = body.metadata \|\| {};\n const thread = await azureAiProject.agents.threads.create({\n metadata\n });\n const openaiThread = {\n id: thread.id,\n object: \"thread\",\n created_at: (0, import_dayjs22.default)(thread.createdAt).unix(),\n metadata: thread.metadata \|\| {},\n tool_resources: null\n };\n return new Response(JSON.stringify(openaiThread), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/index.ts\nvar threads3 = ({\n azureAiProject\n}) => ({\n post: post23({ azureAiProject })\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/messages/post.ts\nvar import_dayjs23 = __toESM(require(\"dayjs\"), 1);\nvar post24 = ({\n azureAiProject,\n runAdapter\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp));\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const { role, content } = body;\n let textContent = \"\";\n if (typeof content === \"string\") {\n textContent = content;\n } else if (Array.isArray(content)) {\n const textItem = content.find((item) => item.type === \"text\");\n if (textItem) {\n textContent = textItem.text;\n }\n }\n const message = await azureAiProject.agents.messages.create(\n threadId,\n role,\n textContent\n );\n const assistantId = message.assistantId \|\| message.assistant_id \|\| null;\n const runId = message.runId \|\| message.run_id \|\| null;\n const openaiMessage = {\n id: message.id,\n object: \"thread.message\",\n created_at: (0, import_dayjs23.default)(message.createdAt).unix(),\n thread_id: message.threadId,\n role: message.role,\n content: message.content.map((c) => {\n if (c.type === \"text\" && \"text\" in c) {\n const annotations = (c.text.annotations \|\| []).map((ann) => {\n if (ann.type === \"file_citation\") {\n return {\n type: \"file_citation\",\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_citation: {\n file_id: ann.fileCitation?.fileId \|\| ann.file_citation?.file_id,\n quote: ann.fileCitation?.quote \|\| ann.file_citation?.quote \|\| \"\"\n }\n };\n } else if (ann.type === \"file_path\") {\n return {\n type: \"file_path\",\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_path: {\n file_id: ann.filePath?.fileId \|\| ann.file_path?.file_id\n }\n };\n }\n return ann;\n });\n return {\n type: \"text\",\n text: {\n value: c.text.value,\n annotations\n }\n };\n } else if (c.type === \"image_file\") {\n const imageFile = c.image_file \|\| c.imageFile \|\| {};\n return {\n type: \"image_file\",\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| \"\",\n detail: imageFile.detail ?? \"auto\"\n }\n };\n }\n return c;\n }),\n assistant_id: assistantId,\n run_id: runId,\n attachments: [],\n metadata: message.metadata \|\| {},\n status: \"completed\",\n completed_at: (0, import_dayjs23.default)(message.createdAt).unix(),\n incomplete_at: null,\n incomplete_details: null\n };\n return new Response(JSON.stringify(openaiMessage), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/messages/get.ts\nvar import_dayjs24 = __toESM(require(\"dayjs\"), 1);\nvar get22 = ({\n azureAiProject,\n runAdapter\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp));\n const order = url.searchParams.get(\"order\") \|\| \"desc\";\n const messages5 = await azureAiProject.agents.messages.list(threadId, {\n order\n });\n const messagesList = [];\n for await (const message of messages5) {\n const assistantId = message.assistantId \|\| message.assistant_id \|\| null;\n const runId = message.runId \|\| message.run_id \|\| null;\n messagesList.push({\n id: message.id,\n object: \"thread.message\",\n created_at: (0, import_dayjs24.default)(message.createdAt).unix(),\n thread_id: message.threadId,\n role: message.role,\n content: message.content.map((c) => {\n if (c.type === \"text\" && \"text\" in c) {\n const annotations = (c.text.annotations \|\| []).map((ann) => {\n if (ann.type === \"file_citation\") {\n return {\n type: \"file_citation\",\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_citation: {\n file_id: ann.fileCitation?.fileId \|\| ann.file_citation?.file_id,\n quote: ann.fileCitation?.quote \|\| ann.file_citation?.quote \|\| \"\"\n }\n };\n } else if (ann.type === \"file_path\") {\n return {\n type: \"file_path\",\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_path: {\n file_id: ann.filePath?.fileId \|\| ann.file_path?.file_id\n }\n };\n }\n return ann;\n });\n return {\n type: \"text\",\n text: {\n value: c.text.value,\n annotations\n }\n };\n } else if (c.type === \"image_file\") {\n const imageFile = c.image_file \|\| c.imageFile \|\| {};\n return {\n type: \"image_file\",\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| \"\",\n detail: imageFile.detail ?? \"auto\"\n }\n };\n }\n return c;\n }),\n assistant_id: assistantId,\n run_id: runId,\n attachments: [],\n metadata: message.metadata \|\| {},\n status: \"completed\",\n completed_at: (0, import_dayjs24.default)(message.createdAt).unix(),\n incomplete_at: null,\n incomplete_details: null\n });\n }\n const response = {\n data: messagesList,\n first_id: messagesList[0]?.id \|\| null,\n last_id: messagesList[messagesList.length - 1]?.id \|\| null,\n has_more: false\n };\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/messages/index.ts\nvar messages4 = ({\n azureAiProject,\n runAdapter\n}) => ({\n post: post24({ azureAiProject, runAdapter }),\n get: get22({ azureAiProject, runAdapter })\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/runs/get.ts\nvar get23 = () => async () => {\n const response = {\n data: [],\n first_id: null,\n last_id: null,\n has_more: false\n };\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/runs/post.ts\nvar import_radash26 = require(\"radash\");\nvar import_dayjs25 = __toESM(require(\"dayjs\"), 1);\nvar post25 = ({\n azureAiProject,\n runAdapter\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp));\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const { assistant_id, stream, instructions, tools } = body;\n if (!assistant_id) {\n throw new Error(\"assistant_id is required\");\n }\n const azureAgentId = assistant_id;\n if (stream) {\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n threadId,\n assistantId: azureAgentId,\n instructions,\n tools,\n onEvent: async (event) => {\n controller.enqueue(`data: ${JSON.stringify(event)}\n\n`);\n }\n });\n } catch (error) {\n console.error(error);\n const event = {\n event: \"thread.run.failed\",\n data: {\n id: (0, import_radash26.uid)(24),\n failed_at: (0, import_dayjs25.default)().unix(),\n last_error: {\n code: \"server_error\",\n message: `${error?.message ?? \"\"} ${error?.cause?.message ?? \"\"}`\n }\n }\n };\n controller.enqueue(`data: ${JSON.stringify(event)}\n\n`);\n }\n controller.close();\n }\n });\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n let azureRun;\n let retries = 0;\n const maxRetries = 10;\n while (retries < maxRetries) {\n try {\n const createOptions = {};\n if (instructions) {\n createOptions.instructions = instructions;\n }\n if (tools) {\n createOptions.tools = tools;\n }\n azureRun = await azureAiProject.agents.runs.create(\n threadId,\n azureAgentId,\n createOptions\n );\n break;\n } catch (error) {\n const errorMessage = error?.message \|\| error?.cause?.message \|\| \"\";\n if (errorMessage.includes(\"already has an active run\")) {\n const runIdMatch = errorMessage.match(/run_[a-zA-Z0-9]+/);\n if (runIdMatch) {\n const activeRunId = runIdMatch[0];\n let activeRun = await azureAiProject.agents.runs.get(threadId, activeRunId);\n while (activeRun.status === \"queued\" \|\| activeRun.status === \"in_progress\") {\n await new Promise((resolve) => setTimeout(resolve, 500));\n activeRun = await azureAiProject.agents.runs.get(threadId, activeRunId);\n }\n if (activeRun.status === \"requires_action\") {\n throw new Error(`Thread ${threadId} has an active run ${activeRunId} that requires action (tool outputs must be submitted before creating a new run)`);\n }\n } else {\n await new Promise((resolve) => setTimeout(resolve, 1e3 Math.pow(2, retries)));\n }\n retries++;\n } else {\n throw error;\n }\n }\n }\n if (!azureRun) {\n throw new Error(`Failed to create run after ${maxRetries} retries`);\n }\n const runData = {\n id: azureRun.id,\n object: \"thread.run\",\n created_at: (0, import_dayjs25.default)(azureRun.createdAt).unix(),\n thread_id: azureRun.threadId,\n assistant_id: azureAgentId,\n status: azureRun.status,\n required_action: null,\n last_error: null,\n expires_at: null,\n started_at: azureRun.status === \"in_progress\" ? (0, import_dayjs25.default)(azureRun.createdAt).unix() : null,\n cancelled_at: null,\n failed_at: null,\n completed_at: null,\n incomplete_details: null,\n model: \"\",\n instructions: \"\",\n tools: [],\n metadata: azureRun.metadata \|\| {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: \"auto\",\n last_messages: null\n },\n response_format: \"auto\",\n tool_choice: \"auto\",\n parallel_tool_calls: true,\n usage: null\n };\n return new Response(JSON.stringify(runData), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/runs/index.ts\nvar runs4 = ({\n azureAiProject,\n runAdapter\n}) => ({\n get: get23(),\n post: post25({ azureAiProject, runAdapter })\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/run/get.ts\nvar import_dayjs26 = __toESM(require(\"dayjs\"), 1);\nvar get24 = ({\n azureAiProject,\n runAdapter\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(runRegexp));\n const azureRun = await azureAiProject.agents.runs.get(threadId, runId);\n const assistantId = azureRun.assistantId;\n const openaiRun = {\n id: azureRun.id,\n object: \"thread.run\",\n created_at: (0, import_dayjs26.default)(azureRun.createdAt).unix(),\n thread_id: azureRun.threadId,\n assistant_id: assistantId,\n status: azureRun.status,\n required_action: azureRun.status === \"requires_action\" && azureRun.requiredAction ? {\n type: \"submit_tool_outputs\",\n submit_tool_outputs: {\n tool_calls: azureRun.requiredAction.submitToolOutputs.toolCalls.map(\n (tc) => ({\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments\n }\n })\n )\n }\n } : null,\n last_error: azureRun.lastError ? {\n code: \"server_error\",\n message: JSON.stringify(azureRun.lastError)\n } : null,\n expires_at: null,\n started_at: (0, import_dayjs26.default)(azureRun.createdAt).unix(),\n cancelled_at: null,\n failed_at: azureRun.status === \"failed\" ? (0, import_dayjs26.default)().unix() : null,\n completed_at: azureRun.status === \"completed\" ? (0, import_dayjs26.default)().unix() : null,\n incomplete_details: null,\n model: \"\",\n instructions: \"\",\n tools: [],\n metadata: azureRun.metadata \|\| {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: \"auto\",\n last_messages: null\n },\n response_format: \"auto\",\n tool_choice: \"auto\",\n parallel_tool_calls: true,\n usage: null\n };\n return new Response(JSON.stringify(openaiRun), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/run/index.ts\nvar run3 = ({\n azureAiProject,\n runAdapter\n}) => ({\n get: get24({ azureAiProject, runAdapter })\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/runs/steps/get.ts\nvar import_dayjs27 = __toESM(require(\"dayjs\"), 1);\nvar get25 = ({\n azureAiProject,\n runAdapter,\n prisma\n}) => async (urlString) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(new RegExp(stepsRegexp));\n const azureSteps = await azureAiProject.agents.runSteps.list(threadId, runId);\n const storedOutputs = await prisma.azureAgentsFunctionOutput.findMany({\n where: { runId }\n });\n const outputsMap = new Map(\n storedOutputs.map((o) => [o.toolCallId, o.output])\n );\n const stepsList = [];\n for await (const step of azureSteps) {\n const assistantId = step.assistantId \|\| step.assistant_id \|\| \"\";\n stepsList.push({\n id: step.id,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs27.default)(step.createdAt).unix(),\n assistant_id: assistantId,\n thread_id: threadId,\n run_id: runId,\n type: step.type === \"tool_calls\" ? \"tool_calls\" : \"message_creation\",\n status: step.status,\n step_details: step.type === \"tool_calls\" ? {\n type: \"tool_calls\",\n tool_calls: step.stepDetails.toolCalls.map(\n (tc) => {\n if (tc.type === \"code_interpreter\") {\n return {\n id: tc.id,\n type: \"code_interpreter\",\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| \"\",\n outputs: tc.codeInterpreter?.outputs?.map((output) => {\n if (output.type === \"logs\") {\n return {\n type: \"logs\",\n logs: output.logs \|\| \"\"\n };\n }\n if (output.type === \"image\") {\n return {\n type: \"image\",\n image: {\n file_id: output.image?.fileId \|\| \"\"\n }\n };\n }\n return output;\n }) \|\| []\n }\n };\n } else if (tc.type === \"file_search\") {\n return {\n id: tc.id,\n type: \"file_search\",\n file_search: tc.fileSearch \|\| {}\n };\n } else if (tc.type === \"function\") {\n return {\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments,\n // Retrieve output from database if Azure doesn't provide it\n // Use nullish coalescing (??) to preserve empty strings\n output: tc.function.output ?? outputsMap.get(tc.id) ?? null\n }\n };\n }\n return tc;\n }\n )\n } : {\n type: \"message_creation\",\n message_creation: {\n message_id: step.stepDetails.messageCreation?.messageId\n }\n },\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: step.completedAt ? (0, import_dayjs27.default)(step.completedAt).unix() : null,\n metadata: step.metadata \|\| {},\n usage: null\n });\n }\n const response = {\n data: stepsList,\n first_id: stepsList[0]?.id \|\| null,\n last_id: stepsList[stepsList.length - 1]?.id \|\| null,\n has_more: false\n };\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/runs/steps/index.ts\nvar steps3 = ({\n azureAiProject,\n runAdapter,\n prisma\n}) => ({\n get: get25({ azureAiProject, runAdapter, prisma })\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/runs/submitToolOutputs/post/index.ts\nvar import_dayjs28 = __toESM(require(\"dayjs\"), 1);\nfunction convertAzureEventToOpenAI(azureEvent, assistantId, outputsMap) {\n const { event, data } = azureEvent;\n const eventType = event;\n if (eventType.startsWith(\"thread.run.\") && !eventType.startsWith(\"thread.run.step.\")) {\n return {\n event: eventType,\n data: {\n id: data.id,\n object: \"thread.run\",\n created_at: (0, import_dayjs28.default)(data.createdAt).unix(),\n thread_id: data.threadId,\n assistant_id: assistantId,\n status: data.status,\n required_action: data.requiredAction ? {\n type: \"submit_tool_outputs\",\n submit_tool_outputs: {\n tool_calls: data.requiredAction.submitToolOutputs?.toolCalls?.map(\n (tc) => ({\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments\n }\n })\n ) \|\| []\n }\n } : null,\n last_error: data.lastError ? {\n code: \"server_error\",\n message: JSON.stringify(data.lastError)\n } : null,\n expires_at: null,\n started_at: data.startedAt ? (0, import_dayjs28.default)(data.startedAt).unix() : null,\n cancelled_at: data.cancelledAt ? (0, import_dayjs28.default)(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? (0, import_dayjs28.default)(data.failedAt).unix() : null,\n completed_at: data.completedAt ? (0, import_dayjs28.default)(data.completedAt).unix() : null,\n incomplete_details: null,\n model: data.model \|\| \"\",\n instructions: data.instructions \|\| \"\",\n tools: data.tools \|\| [],\n metadata: data.metadata \|\| {},\n temperature: data.temperature ?? null,\n top_p: data.topP ?? null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: \"auto\",\n last_messages: null\n },\n response_format: \"auto\",\n tool_choice: \"auto\",\n parallel_tool_calls: true,\n usage: null\n }\n };\n }\n if (eventType.startsWith(\"thread.message.\") && eventType !== \"thread.message.delta\") {\n return {\n event: eventType,\n data: {\n id: data.id,\n object: \"thread.message\",\n created_at: (0, import_dayjs28.default)(data.createdAt).unix(),\n thread_id: data.threadId,\n role: data.role,\n content: data.content?.map((c) => {\n if (c.type === \"text\") {\n return {\n type: \"text\",\n text: {\n value: c.text?.value \|\| \"\",\n annotations: c.text?.annotations \|\| []\n }\n };\n }\n return c;\n }) \|\| [],\n assistant_id: assistantId,\n run_id: data.runId \|\| null,\n attachments: data.attachments \|\| [],\n metadata: data.metadata \|\| {},\n status: data.status \|\| \"completed\",\n completed_at: data.completedAt ? (0, import_dayjs28.default)(data.completedAt).unix() : null,\n incomplete_at: null,\n incomplete_details: null\n }\n };\n }\n if (eventType === \"thread.message.delta\") {\n return {\n event: \"thread.message.delta\",\n data: {\n id: data.id,\n object: \"thread.message.delta\",\n delta: {\n content: data.delta?.content?.map((c) => {\n if (c.type === \"text\") {\n return {\n index: c.index \|\| 0,\n type: \"text\",\n text: {\n value: c.text?.value \|\| \"\",\n annotations: c.text?.annotations \|\| []\n }\n };\n }\n return c;\n }) \|\| []\n }\n }\n };\n }\n if (eventType === \"thread.run.step.delta\") {\n if (!data.delta?.stepDetails \|\| !data.delta.stepDetails.type) {\n return null;\n }\n let stepDetailsDelta = void 0;\n if (data.delta?.stepDetails) {\n const details = data.delta.stepDetails;\n if (details.type === \"tool_calls\") {\n stepDetailsDelta = {\n type: \"tool_calls\",\n tool_calls: details.toolCalls?.map((tc) => {\n if (tc.type === \"code_interpreter\") {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: \"code_interpreter\",\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| \"\",\n outputs: tc.codeInterpreter?.outputs?.map((output) => {\n if (output.type === \"logs\") {\n return {\n index: output.index ?? 0,\n type: \"logs\",\n logs: output.logs \|\| \"\"\n };\n }\n if (output.type === \"image\") {\n return {\n index: output.index ?? 0,\n type: \"image\",\n image: {\n file_id: output.image?.fileId \|\| \"\"\n }\n };\n }\n return output;\n }) \|\| []\n }\n };\n } else if (tc.type === \"file_search\") {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: \"file_search\",\n file_search: tc.fileSearch \|\| {}\n };\n } else if (tc.type === \"function\") {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function?.name \|\| \"\",\n arguments: tc.function?.arguments \|\| \"\",\n output: tc.function?.output ?? outputsMap.get(tc.id) ?? null\n }\n };\n }\n return tc;\n }) \|\| []\n };\n } else {\n stepDetailsDelta = details;\n }\n }\n if (stepDetailsDelta === void 0) {\n return null;\n }\n return {\n event: \"thread.run.step.delta\",\n data: {\n id: data.id,\n object: \"thread.run.step.delta\",\n delta: {\n step_details: stepDetailsDelta\n }\n }\n };\n }\n if (eventType.startsWith(\"thread.run.step.\")) {\n if (!data.stepDetails \|\| !data.stepDetails.type \|\| !data.type) {\n return null;\n }\n let stepDetails = void 0;\n if (data.stepDetails) {\n if (data.stepDetails.type === \"message_creation\") {\n stepDetails = {\n type: \"message_creation\",\n message_creation: {\n message_id: data.stepDetails.messageCreation?.messageId \|\| \"\"\n }\n };\n } else if (data.stepDetails.type === \"tool_calls\") {\n stepDetails = {\n type: \"tool_calls\",\n tool_calls: data.stepDetails.toolCalls?.map((tc) => {\n if (tc.type === \"code_interpreter\") {\n return {\n id: tc.id,\n type: \"code_interpreter\",\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| \"\",\n outputs: tc.codeInterpreter?.outputs?.map((output) => {\n if (output.type === \"logs\") {\n return {\n type: \"logs\",\n logs: output.logs \|\| \"\"\n };\n }\n if (output.type === \"image\") {\n return {\n type: \"image\",\n image: {\n file_id: output.image?.fileId \|\| \"\"\n }\n };\n }\n return output;\n }) \|\| []\n }\n };\n } else if (tc.type === \"file_search\") {\n return {\n id: tc.id,\n type: \"file_search\",\n file_search: tc.fileSearch \|\| {}\n };\n } else if (tc.type === \"function\") {\n return {\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function?.name \|\| \"\",\n arguments: tc.function?.arguments \|\| \"\",\n output: tc.function?.output ?? outputsMap.get(tc.id) ?? null\n }\n };\n }\n return tc;\n }) \|\| []\n };\n } else {\n stepDetails = data.stepDetails;\n }\n }\n if (stepDetails === void 0) {\n return null;\n }\n return {\n event: eventType,\n data: {\n id: data.id,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs28.default)(data.createdAt).unix(),\n assistant_id: assistantId,\n thread_id: data.threadId,\n run_id: data.runId,\n type: data.type,\n status: data.status,\n step_details: stepDetails,\n last_error: data.lastError \|\| null,\n expired_at: null,\n cancelled_at: data.cancelledAt ? (0, import_dayjs28.default)(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? (0, import_dayjs28.default)(data.failedAt).unix() : null,\n completed_at: data.completedAt ? (0, import_dayjs28.default)(data.completedAt).unix() : null,\n metadata: data.metadata \|\| {},\n usage: null\n }\n };\n }\n if (eventType === \"thread.created\") {\n return {\n event: \"thread.created\",\n data: {\n id: data.id,\n object: \"thread\",\n created_at: (0, import_dayjs28.default)(data.createdAt).unix(),\n metadata: data.metadata \|\| {},\n tool_resources: data.toolResources \|\| null\n }\n };\n }\n return null;\n}\nvar post26 = ({\n azureAiProject,\n runAdapter,\n prisma\n}) => async (urlString, options) => {\n const url = new URL(urlString);\n const [, threadId, runId] = url.pathname.match(\n new RegExp(submitToolOutputsRegexp)\n );\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const { tool_outputs, stream } = body;\n const outputsMap = new Map(\n tool_outputs.map((output) => [\n output.tool_call_id,\n output.output\n ])\n );\n await Promise.all(\n tool_outputs.map(\n (output) => prisma.azureAgentsFunctionOutput.upsert({\n where: {\n runId_toolCallId: {\n runId,\n toolCallId: output.tool_call_id\n }\n },\n create: {\n runId,\n toolCallId: output.tool_call_id,\n output: output.output\n },\n update: {\n output: output.output\n }\n })\n )\n );\n const existingRun = await azureAiProject.agents.runs.get(threadId, runId);\n const assistantId = existingRun.assistantId;\n const submitResponse = azureAiProject.agents.runs.submitToolOutputs(\n threadId,\n runId,\n tool_outputs.map((to) => ({\n toolCallId: to.tool_call_id,\n output: to.output\n }))\n );\n const streamRun = async (onEvent2) => {\n try {\n const stream2 = await submitResponse.stream();\n for await (const azureEvent of stream2) {\n const openaiEvent = convertAzureEventToOpenAI(azureEvent, assistantId, outputsMap);\n if (openaiEvent) {\n await onEvent2(openaiEvent);\n }\n }\n } catch (error) {\n await onEvent2({\n event: \"thread.run.failed\",\n data: {\n id: runId,\n object: \"thread.run\",\n created_at: (0, import_dayjs28.default)().unix(),\n thread_id: threadId,\n assistant_id: assistantId,\n status: \"failed\",\n required_action: null,\n last_error: {\n code: \"server_error\",\n message: `${error?.message ?? \"\"} ${error?.cause?.message ?? \"\"}`\n },\n expires_at: null,\n started_at: (0, import_dayjs28.default)().unix(),\n cancelled_at: null,\n failed_at: (0, import_dayjs28.default)().unix(),\n completed_at: null,\n incomplete_details: null,\n model: \"\",\n instructions: \"\",\n tools: [],\n metadata: {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: { type: \"auto\", last_messages: null },\n response_format: \"auto\",\n tool_choice: \"auto\",\n parallel_tool_calls: true,\n usage: null\n }\n });\n }\n };\n const readableStream = new ReadableStream({\n async start(controller) {\n await streamRun(async (event) => {\n controller.enqueue(`data: ${JSON.stringify(event)}\n\n`);\n });\n controller.close();\n }\n });\n if (stream) {\n return new Response(readableStream, {\n headers: {\n \"Content-Type\": \"text/event-stream\"\n }\n });\n } else {\n const events = [];\n let finalRun = null;\n await streamRun(async (event) => {\n events.push(event);\n if (event.event === \"thread.run.completed\" \|\| event.event === \"thread.run.failed\" \|\| event.event === \"thread.run.requires_action\") {\n finalRun = event.data;\n }\n });\n if (!finalRun) {\n throw new Error(\"Run did not complete\");\n }\n return new Response(JSON.stringify(finalRun), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/threads/runs/submitToolOutputs/index.ts\nvar submitToolOutputs4 = ({\n azureAiProject,\n runAdapter,\n prisma\n}) => ({\n post: post26({ azureAiProject, runAdapter, prisma })\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/assistants/post.ts\nvar post27 = ({ runAdapter }) => async (_urlString, options) => {\n if (typeof options.body !== \"string\") {\n throw new Error(\"Request body is required\");\n }\n const body = JSON.parse(options.body);\n const openaiAssistant = {\n id: \"placeholder\",\n // This will be overridden by the assistant_id passed to createRun\n object: \"assistant\",\n created_at: Math.floor(Date.now() / 1e3),\n name: body.name \|\| null,\n description: body.description \|\| null,\n model: body.model,\n instructions: body.instructions \|\| null,\n tools: body.tools \|\| [],\n metadata: body.metadata \|\| {},\n top_p: body.top_p ?? null,\n temperature: body.temperature ?? null,\n response_format: body.response_format \|\| \"auto\"\n };\n return new Response(JSON.stringify(openaiAssistant), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/assistants/index.ts\nvar assistants3 = ({\n runAdapter\n}) => ({\n post: post27({ runAdapter })\n});\n\n// src/lib/files/fileRegexp.ts\nvar fileRegexp = \"^/(?:v1\|/?openai)/files/([^/]+)$\";\n\n// src/lib/files/fileContentRegexp.ts\nvar fileContentRegexp = \"^/(?:v1\|/?openai)/files/([^/]+)/content$\";\n\n// src/lib/files/transformAzureFile.ts\nvar import_dayjs29 = __toESM(require(\"dayjs\"), 1);\nvar toUnixSeconds = (value) => {\n if (!value) return void 0;\n if (value instanceof Date) {\n return (0, import_dayjs29.default)(value).unix();\n }\n if (typeof value === \"number\") {\n if (value > 9999999999) {\n return (0, import_dayjs29.default)(value).unix();\n }\n return Math.floor(value);\n }\n const parsed = (0, import_dayjs29.default)(value);\n return parsed.isValid() ? parsed.unix() : void 0;\n};\nvar transformAzureFile = (file2) => {\n const createdAtUnix = toUnixSeconds(file2.createdAt) ?? (0, import_dayjs29.default)().unix();\n const expiresAtUnix = toUnixSeconds(file2.expiresAt);\n const openaiFile = {\n id: file2.id,\n object: file2.object \|\| \"file\",\n bytes: file2.bytes ?? 0,\n created_at: createdAtUnix,\n filename: file2.filename \|\| \"file\",\n purpose: file2.purpose \|\| \"assistants\",\n status: file2.status \|\| \"processed\"\n };\n if (expiresAtUnix !== void 0) {\n openaiFile.expires_at = expiresAtUnix;\n }\n if (file2.statusDetails) {\n openaiFile.status_details = file2.statusDetails;\n }\n return openaiFile;\n};\n\n// src/adapters/storage/azureAgentsStorageAdapter/files/get.ts\nvar file = ({\n azureAiProject\n}) => ({\n get: async (url) => {\n const { pathname } = new URL(url);\n const match = pathname.match(new RegExp(fileRegexp));\n if (!match) {\n return new Response(\"Not Found\", { status: 404 });\n }\n const [, fileId] = match;\n const azureFile = await azureAiProject.agents.files.get(fileId);\n const openaiFile = transformAzureFile(azureFile);\n return new Response(JSON.stringify(openaiFile), {\n status: 200,\n headers: {\n \"Content-Type\": \"application/json\"\n }\n });\n }\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/files/content.ts\nvar import_node_stream = require(\"stream\");\nvar headersToRecord = (headers) => {\n if (!headers) return {};\n if (typeof headers.get === \"function\") {\n const result = {};\n for (const headerName of [\"content-type\", \"content-length\"]) {\n const value = headers.get(headerName);\n if (value) {\n result[headerName] = value;\n }\n }\n return result;\n }\n const json = typeof headers.toJSON === \"function\" ? headers.toJSON() : headers;\n return typeof json === \"object\" && json !== null ? json : {};\n};\nvar toBody = async (nodeStream) => {\n if (typeof import_node_stream.Readable.toWeb === \"function\") {\n return import_node_stream.Readable.toWeb(nodeStream);\n }\n const chunks = [];\n for await (const chunk of nodeStream) {\n chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));\n }\n return Buffer.concat(chunks);\n};\nvar fileContent = ({\n azureAiProject\n}) => ({\n get: async (url) => {\n const { pathname } = new URL(url);\n const match = pathname.match(new RegExp(fileContentRegexp));\n if (!match) {\n return new Response(\"Not Found\", { status: 404 });\n }\n const [, fileId] = match;\n const streamable = azureAiProject.agents.files.getContent(fileId);\n if (!streamable \|\| typeof streamable.asNodeStream !== \"function\") {\n return new Response(\"File content unavailable\", { status: 500 });\n }\n const nodeResponse = await streamable.asNodeStream();\n const nodeStream = nodeResponse.body;\n if (!nodeStream) {\n return new Response(\"\", { status: 204 });\n }\n const headerRecord = headersToRecord(nodeResponse.headers);\n const headers = new Headers();\n for (const [key, value] of Object.entries(headerRecord)) {\n headers.set(key, value);\n }\n if (!headers.has(\"content-type\")) {\n headers.set(\"Content-Type\", \"application/octet-stream\");\n }\n const body = await toBody(nodeStream);\n return new Response(body, {\n status: nodeResponse.status ?? 200,\n headers\n });\n }\n});\n\n// src/adapters/storage/azureAgentsStorageAdapter/index.ts\nvar azureAgentsStorageAdapter = ({\n azureAiProject,\n prisma\n}) => {\n return ({ runAdapter }) => ({\n requestHandlers: {\n \"^/(?:v1\|/?openai)/assistants$\": assistants3({ runAdapter }),\n \"^/(?:v1\|/?openai)/threads$\": threads3({ azureAiProject }),\n [messagesRegexp]: messages4({ azureAiProject, runAdapter }),\n [runsRegexp]: runs4({ azureAiProject, runAdapter }),\n [runRegexp]: run3({ azureAiProject, runAdapter }),\n [stepsRegexp]: steps3({ azureAiProject, runAdapter, prisma }),\n [submitToolOutputsRegexp]: submitToolOutputs4({ azureAiProject, runAdapter, prisma }),\n [fileRegexp]: file({ azureAiProject }),\n [fileContentRegexp]: fileContent({ azureAiProject })\n }\n });\n};\n\n// src/adapters/run/responsesRunAdapter/index.ts\nvar import_dayjs30 = __toESM(require(\"dayjs\"), 1);\nvar import_radash27 = require(\"radash\");\nvar serializeToolCalls2 = ({\n toolCalls\n}) => toolCalls.map((toolCall) => {\n if (toolCall.type === \"function_call\") {\n return {\n id: toolCall.call_id,\n type: \"function\",\n function: {\n name: toolCall.name,\n arguments: toolCall.arguments\n }\n };\n } else if (toolCall.type === \"computer_call\") {\n return {\n id: toolCall.call_id,\n type: \"computer_call\",\n computer_call: {\n action: toolCall.action,\n pending_safety_checks: toolCall.pending_safety_checks\n }\n };\n }\n});\nvar responsesRunAdapter = ({\n getOpenaiAssistant: getDirectOpenaiAssistant,\n waitUntil = (p) => p.then(() => {\n })\n}) => {\n let cachedOpenaiAssistant = null;\n const getOpenaiAssistant = async ({ select: { id = false } = {} } = {}) => {\n const args = { select: { id } };\n if (args.select.id) {\n return {\n id: (await getDirectOpenaiAssistant({ select: { id: true } })).id\n };\n }\n if (cachedOpenaiAssistant) return cachedOpenaiAssistant;\n cachedOpenaiAssistant = await getDirectOpenaiAssistant();\n return cachedOpenaiAssistant;\n };\n const handleRun = async ({\n client,\n threadId,\n response,\n onEvent: onEvent2\n }) => {\n let responseCreatedResponse = null;\n let responseCompletedResponse = null;\n const toolCalls = {};\n const mcpCalls = {};\n const codeInterpreterCalls = {};\n let itemIds = [];\n try {\n for await (const event of response) {\n switch (event.type) {\n case \"response.created\":\n responseCreatedResponse = event.response;\n await onEvent2({\n event: \"thread.run.created\",\n data: serializeResponseAsRun({\n response: event.response,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id\n })\n });\n break;\n case \"response.in_progress\":\n await onEvent2({\n event: \"thread.run.in_progress\",\n data: serializeResponseAsRun({\n response: event.response,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id\n })\n });\n break;\n case \"response.completed\": {\n responseCompletedResponse = event.response;\n itemIds = event.response.output.filter((o) => o.id).map((o) => o.id);\n break;\n }\n case \"response.failed\": {\n await onEvent2({\n event: \"thread.run.failed\",\n data: serializeResponseAsRun({\n response: event.response,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id\n })\n });\n break;\n }\n case \"response.output_text.delta\": {\n await onEvent2({\n event: \"thread.message.delta\",\n data: {\n id: event.item_id,\n delta: {\n content: [{ type: \"text\", index: event.content_index, text: { value: event.delta } }]\n }\n }\n });\n break;\n }\n // case 'response.output_text.done': {\n // break\n // }\n //\n case \"response.output_item.added\": {\n if (event.item.type === \"message\") {\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n } else if (event.item.type === \"function_call\") {\n toolCalls[event.item.id] = event.item;\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"computer_call\") {\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsComputerCallRunStep({\n item: event.item,\n items: [],\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id,\n completedAt: null\n })\n });\n } else if (event.item.type === \"image_generation_call\") {\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsImageGenerationRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n } else if (event.item.type === \"reasoning\") {\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsReasoningRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id,\n completedAt: null\n })\n });\n } else if (event.item.type === \"web_search_call\") {\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsWebSearchRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id,\n completedAt: null\n })\n });\n } else if (event.item.type === \"mcp_list_tools\") {\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMcpListToolsRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id,\n completedAt: null\n })\n });\n } else if (event.item.type === \"mcp_call\") {\n mcpCalls[event.item.id] = event.item;\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMcpCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id,\n completedAt: null\n })\n });\n } else if (event.item.type === \"code_interpreter_call\") {\n codeInterpreterCalls[event.item.id] = event.item;\n await onEvent2({\n event: \"thread.message.created\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id,\n status: \"in_progress\"\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id,\n status: \"in_progress\",\n completedAt: null\n })\n });\n await onEvent2({\n event: \"thread.run.step.created\",\n data: serializeItemAsCodeInterpreterCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id,\n completedAt: null\n })\n });\n }\n if (event.item.id) itemIds.push(event.item.id);\n break;\n }\n case \"response.output_item.done\": {\n if (event.item.type === \"message\") {\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.message.completed\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"function_call\") {\n toolCalls[event.item.id] = event.item;\n await onEvent2({\n event: \"thread.run.step.in_progress\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"image_generation_call\") {\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsImageGenerationRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.message.completed\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"reasoning\") {\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsReasoningRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.message.completed\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"web_search_call\") {\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsWebSearchRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.message.completed\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"mcp_list_tools\") {\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMcpListToolsRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.message.completed\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"mcp_call\") {\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMcpCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.message.completed\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id\n })\n });\n } else if (event.item.type === \"code_interpreter_call\") {\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsCodeInterpreterCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.run.step.completed\",\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse.id\n })\n });\n await onEvent2({\n event: \"thread.message.completed\",\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: (0, import_dayjs30.default)().unix(),\n runId: responseCreatedResponse.id\n })\n });\n }\n break;\n }\n case \"response.function_call_arguments.delta\": {\n const toolCall = toolCalls[event.item_id];\n if (!toolCall) break;\n await onEvent2({\n event: \"thread.run.step.delta\",\n data: {\n id: event.item_id,\n object: \"thread.run.step.delta\",\n delta: {\n step_details: {\n type: \"tool_calls\",\n tool_calls: [\n {\n id: toolCall.call_id,\n type: \"function\",\n index: event.output_index,\n function: {\n name: toolCall.name,\n arguments: event.delta,\n output: null\n }\n }\n ]\n }\n }\n }\n });\n break;\n }\n case \"response.mcp_call_arguments.delta\": {\n const mcpCall = mcpCalls[event.item_id];\n if (!mcpCall) break;\n await onEvent2({\n event: \"thread.run.step.delta\",\n data: {\n id: `fc${event.item_id}`,\n object: \"thread.run.step.delta\",\n delta: {\n step_details: {\n type: \"tool_calls\",\n tool_calls: [\n {\n id: `ftc${mcpCall.id}`,\n type: \"function\",\n index: event.output_index,\n function: {\n name: mcpCall.name,\n arguments: event.delta,\n output: null\n }\n }\n ]\n }\n }\n }\n });\n break;\n }\n case \"response.image_generation_call.in_progress\":\n case \"response.image_generation_call.generating\":\n await onEvent2({\n event: \"thread.message.in_progress\",\n data: {\n id: event.item_id,\n object: \"thread.message\",\n created_at: (0, import_dayjs30.default)().unix(),\n thread_id: threadId,\n completed_at: null,\n incomplete_at: null,\n incomplete_details: null,\n role: \"assistant\",\n content: [],\n assistant_id: (await getOpenaiAssistant({ select: { id: true } })).id,\n run_id: responseCreatedResponse.id,\n attachments: [],\n status: \"in_progress\",\n metadata: {\n event: JSON.stringify(event)\n }\n }\n });\n break;\n case \"response.image_generation_call.partial_image\": {\n await onEvent2({\n event: \"thread.message.in_progress\",\n data: {\n id: event.item_id,\n object: \"thread.message\",\n created_at: (0, import_dayjs30.default)().unix(),\n thread_id: threadId,\n completed_at: null,\n incomplete_at: null,\n incomplete_details: null,\n role: \"assistant\",\n content: [{\n type: \"image_url\",\n image_url: {\n url: `data:image/png;base64,${event.partial_image_b64}`,\n // url: `data:image/png;base64,truncated`,\n detail: \"auto\"\n }\n }],\n assistant_id: (await getOpenaiAssistant({ select: { id: true } })).id,\n run_id: responseCreatedResponse.id,\n attachments: [],\n status: \"in_progress\",\n metadata: {\n event: JSON.stringify({\n ...event,\n partial_image_b64: \"truncated\"\n })\n }\n }\n });\n break;\n }\n //\n // case 'response.function_call_arguments.done': {\n // break\n // }\n default:\n break;\n }\n }\n if (responseCompletedResponse) {\n const toolCalls2 = (responseCompletedResponse.output ?? []).filter(\n (o) => o.type === \"function_call\" \|\| o.type === \"computer_call\"\n );\n const serializedRun = serializeResponseAsRun({\n response: responseCompletedResponse,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id\n });\n if (toolCalls2.length > 0) {\n await onEvent2({\n event: \"thread.run.requires_action\",\n data: {\n ...serializedRun,\n status: \"requires_action\",\n required_action: {\n type: \"submit_tool_outputs\",\n submit_tool_outputs: {\n tool_calls: serializeToolCalls2({ toolCalls: toolCalls2 })\n }\n }\n }\n });\n } else {\n await onEvent2({\n event: \"thread.run.completed\",\n data: serializedRun\n });\n }\n }\n } catch (e) {\n await onEvent2({\n event: \"thread.run.failed\",\n data: {\n id: responseCreatedResponse?.id \|\| `run_${(0, import_radash27.uid)(18)}`,\n object: \"thread.run\",\n thread_id: threadId,\n assistant_id: (await getOpenaiAssistant({ select: { id: true } })).id,\n status: \"failed\",\n failed_at: (0, import_dayjs30.default)().unix(),\n last_error: {\n code: \"server_error\",\n message: String(e?.message \|\| e \|\| \"Unknown error\")\n }\n }\n });\n } finally {\n waitUntil(new Promise(async (resolve) => {\n if (responseCreatedResponse?.id && itemIds.length > 0) {\n await saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId: responseCreatedResponse.id,\n itemIds\n });\n }\n resolve(true);\n }));\n }\n };\n return {\n handleRun,\n getOpenaiAssistant\n };\n};\n\n// src/adapters/run/azureAgentsRunAdapter/index.ts\nvar import_dayjs31 = __toESM(require(\"dayjs\"), 1);\nvar import_radash28 = require(\"radash\");\nfunction transformAnnotations(annotations) {\n return annotations.map((ann) => {\n if (ann.type === \"file_citation\") {\n return {\n type: \"file_citation\",\n text: ann.text,\n start_index: ann.startIndex ?? ann.start_index,\n end_index: ann.endIndex ?? ann.end_index,\n file_citation: {\n file_id: ann.fileCitation?.fileId \|\| ann.file_citation?.file_id,\n quote: ann.fileCitation?.quote \|\| ann.file_citation?.quote \|\| \"\"\n }\n };\n } else if (ann.type === \"file_path\") {\n return {\n type: \"file_path\",\n text: ann.text,\n start_index: ann.startIndex ?? ann.start_index,\n end_index: ann.endIndex ?? ann.end_index,\n file_path: {\n file_id: ann.filePath?.fileId \|\| ann.file_path?.file_id\n }\n };\n }\n return ann;\n });\n}\nfunction transformMessageContentItem(content) {\n if (content.type === \"text\") {\n return {\n type: \"text\",\n text: {\n value: content.text?.value \|\| \"\",\n annotations: transformAnnotations(content.text?.annotations \|\| [])\n }\n };\n }\n if (content.type === \"image_file\") {\n const imageFile = content.image_file \|\| content.imageFile \|\| {};\n return {\n type: \"image_file\",\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| \"\",\n detail: imageFile.detail ?? \"auto\"\n }\n };\n }\n return content;\n}\nfunction transformMessageDeltaContentItem(content) {\n if (content.type === \"text\") {\n return {\n index: content.index \|\| 0,\n type: \"text\",\n text: {\n value: content.text?.value \|\| \"\",\n annotations: transformAnnotations(content.text?.annotations \|\| [])\n }\n };\n }\n if (content.type === \"image_file\") {\n const imageFile = content.image_file \|\| content.imageFile \|\| {};\n return {\n index: content.index \|\| 0,\n type: \"image_file\",\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| \"\",\n detail: imageFile.detail ?? \"auto\"\n }\n };\n }\n return content;\n}\nfunction convertAzureEventToOpenAI2(azureEvent, assistantId) {\n const { event, data } = azureEvent;\n const eventType = event;\n if (eventType.startsWith(\"thread.run.\") && !eventType.startsWith(\"thread.run.step.\")) {\n return {\n event: eventType,\n data: {\n id: data.id,\n object: \"thread.run\",\n created_at: (0, import_dayjs31.default)(data.createdAt).unix(),\n thread_id: data.threadId,\n assistant_id: assistantId,\n status: data.status,\n required_action: data.requiredAction ? {\n type: \"submit_tool_outputs\",\n submit_tool_outputs: {\n tool_calls: data.requiredAction.submitToolOutputs?.toolCalls?.map(\n (tc) => ({\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments\n }\n })\n ) \|\| []\n }\n } : null,\n last_error: data.lastError ? {\n code: \"server_error\",\n message: JSON.stringify(data.lastError)\n } : null,\n expires_at: null,\n started_at: data.startedAt ? (0, import_dayjs31.default)(data.startedAt).unix() : null,\n cancelled_at: data.cancelledAt ? (0, import_dayjs31.default)(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? (0, import_dayjs31.default)(data.failedAt).unix() : null,\n completed_at: data.completedAt ? (0, import_dayjs31.default)(data.completedAt).unix() : null,\n incomplete_details: null,\n model: data.model \|\| \"\",\n instructions: data.instructions \|\| \"\",\n tools: data.tools \|\| [],\n metadata: data.metadata \|\| {},\n temperature: data.temperature ?? null,\n top_p: data.topP ?? null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: \"auto\",\n last_messages: null\n },\n response_format: \"auto\",\n tool_choice: \"auto\",\n parallel_tool_calls: true,\n usage: null\n }\n };\n }\n if (eventType.startsWith(\"thread.message.\") && eventType !== \"thread.message.delta\") {\n return {\n event: eventType,\n data: {\n id: data.id,\n object: \"thread.message\",\n created_at: (0, import_dayjs31.default)(data.createdAt).unix(),\n thread_id: data.threadId,\n role: data.role,\n content: data.content?.map((c) => transformMessageContentItem(c)) \|\| [],\n assistant_id: assistantId,\n run_id: data.runId \|\| null,\n attachments: data.attachments \|\| [],\n metadata: data.metadata \|\| {},\n status: data.status \|\| \"completed\",\n completed_at: data.completedAt ? (0, import_dayjs31.default)(data.completedAt).unix() : null,\n incomplete_at: null,\n incomplete_details: null\n }\n };\n }\n if (eventType === \"thread.message.delta\") {\n return {\n event: \"thread.message.delta\",\n data: {\n id: data.id,\n object: \"thread.message.delta\",\n delta: {\n content: data.delta?.content?.map((c) => transformMessageDeltaContentItem(c)) \|\| []\n }\n }\n };\n }\n if (eventType === \"thread.run.step.delta\") {\n if (!data.delta?.stepDetails \|\| !data.delta.stepDetails.type) {\n return null;\n }\n let stepDetailsDelta = void 0;\n if (data.delta?.stepDetails) {\n const details = data.delta.stepDetails;\n if (details.type === \"tool_calls\") {\n stepDetailsDelta = {\n type: \"tool_calls\",\n tool_calls: details.toolCalls?.map((tc) => {\n if (tc.type === \"code_interpreter\") {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: \"code_interpreter\",\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| \"\",\n outputs: tc.codeInterpreter?.outputs?.map((output) => {\n if (output.type === \"logs\") {\n return {\n index: output.index ?? 0,\n type: \"logs\",\n logs: output.logs \|\| \"\"\n };\n }\n if (output.type === \"image\") {\n return {\n index: output.index ?? 0,\n type: \"image\",\n image: {\n file_id: output.image?.fileId \|\| \"\"\n }\n };\n }\n return output;\n }) \|\| []\n }\n };\n } else if (tc.type === \"file_search\") {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: \"file_search\",\n file_search: tc.fileSearch \|\| {}\n };\n } else if (tc.type === \"function\") {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function?.name \|\| \"\",\n arguments: tc.function?.arguments \|\| \"\",\n output: tc.function?.output \|\| null\n }\n };\n }\n return tc;\n }) \|\| []\n };\n } else {\n stepDetailsDelta = details;\n }\n }\n if (stepDetailsDelta === void 0) {\n return null;\n }\n return {\n event: \"thread.run.step.delta\",\n data: {\n id: data.id,\n object: \"thread.run.step.delta\",\n delta: {\n step_details: stepDetailsDelta\n }\n }\n };\n }\n if (eventType.startsWith(\"thread.run.step.\")) {\n if (!data.stepDetails \|\| !data.stepDetails.type \|\| !data.type) {\n return null;\n }\n let stepDetails = void 0;\n if (data.stepDetails) {\n if (data.stepDetails.type === \"message_creation\") {\n stepDetails = {\n type: \"message_creation\",\n message_creation: {\n message_id: data.stepDetails.messageCreation?.messageId \|\| \"\"\n }\n };\n } else if (data.stepDetails.type === \"tool_calls\") {\n stepDetails = {\n type: \"tool_calls\",\n tool_calls: data.stepDetails.toolCalls?.map((tc) => {\n if (tc.type === \"code_interpreter\") {\n return {\n id: tc.id,\n type: \"code_interpreter\",\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| \"\",\n outputs: tc.codeInterpreter?.outputs?.map((output) => {\n if (output.type === \"logs\") {\n return {\n type: \"logs\",\n logs: output.logs \|\| \"\"\n };\n }\n if (output.type === \"image\") {\n return {\n type: \"image\",\n image: {\n file_id: output.image?.fileId \|\| \"\"\n }\n };\n }\n return output;\n }) \|\| []\n }\n };\n } else if (tc.type === \"file_search\") {\n return {\n id: tc.id,\n type: \"file_search\",\n file_search: tc.fileSearch \|\| {}\n };\n } else if (tc.type === \"function\") {\n return {\n id: tc.id,\n type: \"function\",\n function: {\n name: tc.function?.name \|\| \"\",\n arguments: tc.function?.arguments \|\| \"\",\n output: tc.function?.output \|\| null\n }\n };\n }\n return tc;\n }) \|\| []\n };\n } else {\n stepDetails = data.stepDetails;\n }\n }\n if (stepDetails === void 0) {\n return null;\n }\n return {\n event: eventType,\n data: {\n id: data.id,\n object: \"thread.run.step\",\n created_at: (0, import_dayjs31.default)(data.createdAt).unix(),\n assistant_id: assistantId,\n thread_id: data.threadId,\n run_id: data.runId,\n type: data.type,\n status: data.status,\n step_details: stepDetails,\n last_error: data.lastError \|\| null,\n expired_at: null,\n cancelled_at: data.cancelledAt ? (0, import_dayjs31.default)(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? (0, import_dayjs31.default)(data.failedAt).unix() : null,\n completed_at: data.completedAt ? (0, import_dayjs31.default)(data.completedAt).unix() : null,\n metadata: data.metadata \|\| {},\n usage: null\n }\n };\n }\n if (eventType === \"thread.created\") {\n return {\n event: \"thread.created\",\n data: {\n id: data.id,\n object: \"thread\",\n created_at: (0, import_dayjs31.default)(data.createdAt).unix(),\n metadata: data.metadata \|\| {},\n tool_resources: data.toolResources \|\| null\n }\n };\n }\n return null;\n}\nvar azureAgentsRunAdapter = ({\n azureAiProject\n}) => {\n const handleRun = async ({\n threadId,\n assistantId,\n instructions,\n tools,\n onEvent: onEvent2\n }) => {\n try {\n const azureAgentId = assistantId;\n const createOptions = {};\n if (instructions) {\n createOptions.instructions = instructions;\n }\n if (tools) {\n createOptions.tools = tools;\n }\n const runResponse = azureAiProject.agents.runs.create(\n threadId,\n azureAgentId,\n createOptions\n );\n const stream = await runResponse.stream();\n for await (const azureEvent of stream) {\n const openaiEvent = convertAzureEventToOpenAI2(azureEvent, assistantId);\n if (openaiEvent) {\n await onEvent2(openaiEvent);\n }\n }\n } catch (e) {\n const errorRunId = `run_${(0, import_radash28.uid)(18)}`;\n await onEvent2({\n event: \"thread.run.failed\",\n data: {\n id: errorRunId,\n object: \"thread.run\",\n created_at: (0, import_dayjs31.default)().unix(),\n thread_id: threadId,\n assistant_id: assistantId,\n status: \"failed\",\n required_action: null,\n last_error: {\n code: \"server_error\",\n message: String(e?.message \|\| e \|\| \"Unknown error\")\n },\n expires_at: null,\n started_at: (0, import_dayjs31.default)().unix(),\n cancelled_at: null,\n failed_at: (0, import_dayjs31.default)().unix(),\n completed_at: null,\n incomplete_details: null,\n model: \"\",\n instructions: \"\",\n tools: [],\n metadata: {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: \"auto\",\n last_messages: null\n },\n response_format: \"auto\",\n tool_choice: \"auto\",\n parallel_tool_calls: true,\n usage: null\n }\n });\n }\n };\n return {\n handleRun\n };\n};\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n anthropicClientAdapter,\n azureAgentsRunAdapter,\n azureAgentsStorageAdapter,\n azureAiProjectClientAdapter,\n azureOpenaiClientAdapter,\n azureResponsesStorageAdapter,\n completionsRunAdapter,\n googleClientAdapter,\n groqClientAdapter,\n humirisClientAdapter,\n mistralClientAdapter,\n ollamaClientAdapter,\n openRouterClientAdapter,\n openaiClientAdapter,\n perplexityClientAdapter,\n prismaStorageAdapter,\n responsesRunAdapter,\n responsesStorageAdapter,\n supercompat,\n togetherClientAdapter\n});\n","export { supercompat } from './supercompat'\nexport { groqClientAdapter } from './adapters/client/groqClientAdapter'\nexport { openaiClientAdapter } from './adapters/client/openaiClientAdapter'\nexport { azureOpenaiClientAdapter } from './adapters/client/azureOpenaiClientAdapter'\nexport { azureAiProjectClientAdapter } from './adapters/client/azureAiProjectClientAdapter'\nexport { mistralClientAdapter } from './adapters/client/mistralClientAdapter'\nexport { perplexityClientAdapter } from './adapters/client/perplexityClientAdapter'\nexport { anthropicClientAdapter } from './adapters/client/anthropicClientAdapter'\nexport { togetherClientAdapter } from './adapters/client/togetherClientAdapter'\nexport { googleClientAdapter } from './adapters/client/googleClientAdapter'\nexport { humirisClientAdapter } from './adapters/client/humirisClientAdapter'\nexport { ollamaClientAdapter } from './adapters/client/ollamaClientAdapter'\nexport { openRouterClientAdapter } from './adapters/client/openRouterClientAdapter'\nexport { completionsRunAdapter } from './adapters/run/completionsRunAdapter'\nexport { prismaStorageAdapter } from './adapters/storage/prismaStorageAdapter'\nexport { responsesStorageAdapter } from './adapters/storage/responsesStorageAdapter'\nexport { azureResponsesStorageAdapter } from './adapters/storage/azureResponsesStorageAdapter'\nexport { azureAgentsStorageAdapter } from './adapters/storage/azureAgentsStorageAdapter'\nexport { responsesRunAdapter } from './adapters/run/responsesRunAdapter'\nexport { azureAgentsRunAdapter } from './adapters/run/azureAgentsRunAdapter'\n","import OpenAI, { AzureOpenAI } from 'openai'\nimport { supercompatFetch, type Args } from './supercompatFetch'\nimport { endpointFromBaseUrl } from '@/lib/azureOpenai/endpointFromBaseUrl'\n\nexport const supercompat = ({\n client,\n storage,\n runAdapter,\n}: Args) => {\n if (client.type === 'AZURE_OPENAI') {\n return new AzureOpenAI({\n apiKey: client.client.apiKey,\n apiVersion: client.client.apiVersion,\n endpoint: endpointFromBaseUrl({ baseURL: client.client.baseURL }),\n fetch: supercompatFetch({\n client,\n storage,\n runAdapter,\n }),\n })\n }\n\n return new OpenAI({\n apiKey: 'SUPERCOMPAT_PLACEHOLDER_OPENAI_KEY',\n fetch: supercompatFetch({\n client,\n storage,\n runAdapter,\n }),\n })\n}\n","import { assign, partob } from 'radash'\nimport { RunAdapter, StorageAdapterArgs } from '@/types'\nimport { supercompat } from '@/supercompat'\n\nconst storageRequestHandlers = ({\n storage,\n runAdapter,\n client,\n}: {\n storage?: (arg0: StorageAdapterArgs) => any\n runAdapter?: RunAdapter\n client: any\n}) => {\n if (!storage) return {}\n if (!runAdapter) return {}\n\n const wrappedClient = supercompat({\n client,\n })\n\n const result = storage({\n runAdapter: {\n ...runAdapter,\n handleRun: partob(runAdapter.handleRun, { client: wrappedClient }),\n },\n client: wrappedClient,\n originalClient: client,\n })\n return result.requestHandlers\n}\n\nexport const requestHandlers = ({\n client,\n storage,\n runAdapter,\n}: {\n client: any\n storage?: (arg0: StorageAdapterArgs) => any\n runAdapter?: RunAdapter\n}) => (\n assign(\n client.requestHandlers,\n storageRequestHandlers({\n storage,\n runAdapter,\n client,\n })\n )\n)\n","export const findRequestHandler = ({\n url,\n requestHandlers,\n}: {\n url: string\n requestHandlers: any\n}) => {\n const pathname = new URL(url).pathname\n\n for (const key in requestHandlers) {\n const regex = new RegExp(key)\n const matches = regex.test(pathname)\n\n if (matches) {\n return requestHandlers[key]\n }\n }\n}\n","export const originalFetch = async ({\n args,\n client,\n}: {\n args: any[]\n client: any\n}) => {\n if (client.client?.fetch) {\n const [url, options] = args\n\n const clientHeaders = await client.client.buildHeaders({\n options: {},\n method: args[1].method.toLowerCase(),\n bodyHeaders: args[1].headers,\n retryCount: 0,\n })\n\n clientHeaders.set('Authorization', `Bearer ${client.client.apiKey}`)\n\n const newOptions = {\n ...options,\n headers: clientHeaders,\n }\n\n return client.client.fetch(url, newOptions)\n } else {\n // @ts-ignore-next-line\n return fetch(...args)\n }\n}\n","import { RunAdapter, StorageAdapterArgs } from '@/types'\nimport { requestHandlers as getRequestHandlers } from './requestHandlers'\nimport { findRequestHandler } from './findRequestHandler'\nimport { originalFetch } from './originalFetch'\n\nexport type Args = {\n client: any\n storage?: (arg0: StorageAdapterArgs) => any\n runAdapter?: RunAdapter\n}\n\nexport const supercompatFetch = ({\n client,\n storage,\n runAdapter,\n}: Args) => {\n const requestHandlers = getRequestHandlers({\n client,\n storage,\n runAdapter,\n })\n\n return async (...args: any[]) => {\n const [url, options] = args\n\n const pathHandler = findRequestHandler({\n url,\n requestHandlers,\n })\n\n if (!pathHandler) {\n return originalFetch({\n client,\n args,\n })\n }\n\n const method = options?.method ?? ''\n\n const requestHandler = pathHandler[method.toLowerCase()]\n\n if (!requestHandler) {\n return originalFetch({\n client,\n args,\n })\n }\n\n return requestHandler(...args)\n }\n}\n","export const endpointFromBaseUrl = ({\n baseURL\n}: {\n baseURL: string\n}) => (\n baseURL.replace(/\\/+openai$/, '')\n)\n","import type Groq from 'groq-sdk'\n\nexport const get = ({\n groq,\n}: {\n groq: Groq\n}) => async (_url: string, _options: any) => {\n try {\n const data = await groq.models.list()\n\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type Groq from 'groq-sdk'\nimport { get } from './get'\n\nexport const models = ({\n groq,\n}: {\n groq: Groq\n}) => ({\n get: get({ groq }),\n})\n","import type Groq from 'groq-sdk'\n\nexport const post = ({\n groq,\n}: {\n groq: Groq\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n\n if (body.stream) {\n const response = await groq.chat.completions.create(body)\n\n const stream = new ReadableStream({\n async start(controller) {\n // @ts-ignore-next-line\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await groq.chat.completions.create(body)\n\n return new Response(JSON.stringify({\n data,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","import type Groq from 'groq-sdk'\nimport { post } from './post'\n\nexport const completions = ({\n groq,\n}: {\n groq: Groq\n}) => ({\n post: post({ groq }),\n})\n","// import type Groq from 'groq-sdk'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const groqClientAdapter = ({\n groq,\n}: {\n // TODO\n groq: any\n}) => ({\n client: groq,\n requestHandlers: {\n '^/v1/models$': models({ groq }),\n '^/v1/chat/completions$': completions({ groq }),\n },\n})\n","import type OpenAI from 'openai'\n\nexport const get = ({\n openai,\n}: {\n openai: OpenAI\n}) => async (_url: string, _options: any) => {\n try {\n const data = await openai.models.list()\n\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type OpenAI from 'openai'\nimport { get } from './get'\n\nexport const models = ({\n openai,\n}: {\n openai: OpenAI\n}) => ({\n get: get({ openai }),\n})\n","import type OpenAI from 'openai'\nimport { omit } from 'radash'\nimport { systemDeveloperMessages } from '@/lib/messages/systemDeveloperMessages'\nimport { isOModel } from '@/lib/models/isOModel'\n\nconst omitKeys = ({\n model,\n}: {\n model: string\n}) => {\n if (isOModel({ model })) {\n return ['tools']\n }\n\n return []\n}\n\nexport const post = ({\n openai,\n}: {\n openai: OpenAI\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n const messages = body.messages as OpenAI.ChatCompletionMessageParam[]\n\n const resultOptions = {\n ...omit(body, omitKeys({ model: body.model })),\n messages: systemDeveloperMessages({\n messages,\n model: body.model,\n }),\n } as OpenAI.Chat.ChatCompletionCreateParams\n\n if (body.stream) {\n const response = await openai.chat.completions.create(resultOptions)\n\n const stream = new ReadableStream({\n async start(controller) {\n // @ts-ignore-next-line\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await openai.chat.completions.create(resultOptions)\n\n return new Response(JSON.stringify({\n data,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","export const isOModel = ({ model }: { model: string }) => (\n model.startsWith('o1') \|\| model.startsWith('o3')\n)\n","import type OpenAI from 'openai'\nimport { isOModel } from '@/lib/models/isOModel'\n\nexport const systemDeveloperMessages = ({\n messages,\n model,\n}: {\n messages: OpenAI.Chat.ChatCompletionMessageParam[]\n model: string\n}): OpenAI.Chat.ChatCompletionMessageParam[] => {\n if (isOModel({ model })) {\n return messages.map((message) => {\n if (message.role === 'system') {\n return {\n ...message,\n // TODO: This should be 'developer' but we're using 'user' for now\n // role: 'developer',\n role: 'user',\n }\n }\n\n return message\n })\n }\n\n return messages\n}\n","import type OpenAI from 'openai'\nimport { post } from './post'\n\nexport const completions = ({\n openai,\n}: {\n openai: OpenAI\n}) => ({\n post: post({ openai }),\n})\n","import type OpenAI from 'openai'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const openaiClientAdapter = ({\n openai,\n}: {\n openai: OpenAI\n}) => ({\n client: openai,\n requestHandlers: {\n '^/v1/models$': models({ openai }),\n '^/(?:v1\|/?openai)/chat/completions$': completions({ openai }),\n },\n})\n","import type { AzureOpenAI } from 'openai'\nimport { completions } from '@/adapters/client/openaiClientAdapter/completions'\n\nexport const azureOpenaiClientAdapter = ({\n azureOpenai,\n}: {\n azureOpenai: AzureOpenAI\n}) => ({\n type: 'AZURE_OPENAI',\n client: azureOpenai,\n requestHandlers: {\n '^/(?:v1\|/?openai)/chat/completions$': completions({\n openai: azureOpenai,\n }),\n },\n})\n","import type { AIProjectClient } from '@azure/ai-projects'\n\nexport const get =\n ({\n azureAiProject,\n }: {\n azureAiProject: AIProjectClient\n }) =>\n async (_url: string, _options: any) => {\n try {\n const models: any[] = []\n\n // List all deployments (models) from Azure AI Project\n for await (const deployment of azureAiProject.deployments.list()) {\n if (\n deployment.type === 'ModelDeployment' &&\n 'modelName' in deployment &&\n 'modelPublisher' in deployment\n ) {\n // Map Azure deployment to OpenAI model format\n models.push({\n id: deployment.modelName,\n object: 'model',\n created: Date.now(),\n owned_by: deployment.modelPublisher,\n })\n }\n }\n\n // Return in OpenAI models.list() format\n return new Response(\n JSON.stringify({\n object: 'list',\n data: models,\n }),\n {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n },\n )\n } catch (error) {\n return new Response(\n JSON.stringify({\n error,\n }),\n {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n },\n )\n }\n }\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport { get } from './get'\n\nexport const models = ({\n azureAiProject,\n}: {\n azureAiProject: AIProjectClient\n}) => ({\n get: get({ azureAiProject }),\n})\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport { models } from './models'\n\n/*\n Client adapter for Azure AI Projects.\n \n Supports both Azure Agents API and Azure Responses API:\n \n @example Azure Agents API\n * ```typescript\n * const client = supercompat({\n * client: azureAiProjectClientAdapter({ azureAiProject }),\n * storage: azureAgentsStorageAdapter(),\n * runAdapter: azureAgentsRunAdapter({ ... })\n * })\n * ```\n \n @example Azure Responses API\n * ```typescript\n * const client = supercompat({\n * client: azureAiProjectClientAdapter({ azureAiProject }),\n * storage: azureResponsesStorageAdapter(),\n * runAdapter: responsesRunAdapter({ ... })\n * })\n * ```\n /\nexport const azureAiProjectClientAdapter = ({\n azureAiProject,\n}: {\n azureAiProject: AIProjectClient\n}) => ({\n type: 'AZURE_AI_PROJECT',\n client: azureAiProject,\n requestHandlers: {\n '^/v1/models$': models({ azureAiProject }),\n },\n})\n","import type { Mistral } from '@mistralai/mistralai'\n\nexport const get = ({\n mistral,\n}: {\n mistral: Mistral\n}) => async (_url: string, _options: any) => {\n try {\n const data = await mistral.models.list()\n\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type { Mistral } from '@mistralai/mistralai'\nimport { get } from './get'\n\nexport const models = ({\n mistral,\n}: {\n mistral: Mistral\n}) => ({\n get: get({ mistral }),\n})\n","const serializeDelta = ({\n delta: {\n toolCalls,\n ...rest\n },\n}: {\n delta: any\n}) => ({\n ...rest,\n ...(toolCalls ? {\n tool_calls: toolCalls,\n } : {}),\n})\n\nconst serializeChoice = ({\n choice: {\n finishReason,\n delta,\n ...rest\n },\n}: {\n choice: any\n}) => ({\n ...rest,\n finish_reason: finishReason ?? null,\n delta: serializeDelta({ delta }),\n})\n\nexport const serializeChunk = ({\n chunk,\n}: {\n chunk: any\n}) => ({\n ...chunk.data,\n ...(chunk.data.choices ? {\n choices: chunk.data.choices.map((choice: any) => (\n serializeChoice({ choice })\n )),\n }: {}),\n})\n","import type OpenAI from 'openai'\n\nconst serializeMessage = ({\n message: {\n // @ts-ignore-next-line\n tool_calls,\n // @ts-ignore-next-line\n tool_call_id,\n ...rest\n },\n}: {\n message: OpenAI.ChatCompletionMessageParam\n}) => ({\n ...rest,\n ...(tool_call_id ? {\n toolCallId: tool_call_id,\n } : {}),\n ...(tool_calls ? {\n toolCalls: tool_calls,\n } : {}),\n})\n\nexport const serializeBody = ({\n body,\n}: {\n body: any\n}) => ({\n ...body,\n messages: body.messages.map((message: OpenAI.ChatCompletionMessageParam) => (\n serializeMessage({\n message,\n })\n )),\n})\n","import type { Mistral } from '@mistralai/mistralai'\nimport { serializeChunk } from './serializeChunk'\nimport { serializeBody } from './serializeBody'\n\nexport const post = ({\n mistral,\n}: {\n mistral: Mistral\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n const serializedBody = serializeBody({\n body,\n })\n\n if (body.stream) {\n const response = await mistral.chat.stream(serializedBody)\n\n const stream = new ReadableStream({\n async start(controller) {\n for await (const chunk of response) {\n const serializedChunk = serializeChunk({\n chunk,\n })\n\n controller.enqueue(`data: ${JSON.stringify(serializedChunk)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await mistral.chat.complete(serializedBody)\n\n return new Response(JSON.stringify({\n data,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","import type { Mistral } from '@mistralai/mistralai'\nimport { post } from './post'\n\nexport const completions = ({\n mistral,\n}: {\n mistral: Mistral\n}) => ({\n post: post({ mistral }),\n})\n","import type { Mistral } from '@mistralai/mistralai'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const mistralClientAdapter = ({\n mistral,\n}: {\n mistral: Mistral\n}) => ({\n client: mistral,\n requestHandlers: {\n '^/v1/models$': models({ mistral }),\n '^/v1/chat/completions$': completions({ mistral }),\n },\n})\n","import type OpenAI from 'openai'\n\nconst models = [\n 'sonar-reasoning-pro',\n 'sonar-reasoning',\n 'sonar-pro',\n 'sonar',\n 'r1-1776',\n 'llama-3.1-sonar-small-128k-online',\n 'llama-3.1-sonar-large-128k-online',\n 'llama-3.1-sonar-huge-128k-online',\n]\n\nexport const get = ({\n perplexity,\n}: {\n perplexity: OpenAI\n}) => async (_url: string, _options: any) => {\n try {\n return new Response(JSON.stringify({\n type: 'list',\n data: models.map((model) => ({\n id: model,\n object: 'model',\n })),\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type OpenAI from 'openai'\nimport { get } from './get'\n\nexport const models = ({\n perplexity,\n}: {\n perplexity: OpenAI\n}) => ({\n get: get({ perplexity }),\n})\n","import type OpenAI from 'openai'\n\nconst agentSideRoles = ['assistant', 'system']\n\nexport const alternatingMessages = ({\n messages,\n}: {\n messages: OpenAI.ChatCompletionMessageParam[]\n}): OpenAI.ChatCompletionMessageParam[] => {\n const result: OpenAI.ChatCompletionMessageParam[] = []\n\n messages.forEach((message, index: number) => {\n result.push(message)\n\n const nextMessage = messages[index + 1]\n if (!nextMessage) return\n\n if (message.role === 'user' && nextMessage.role === 'user') {\n result.push({\n role: 'assistant',\n content: '-',\n } as OpenAI.ChatCompletionMessageParam)\n } else if (agentSideRoles.includes(message.role) && agentSideRoles.includes(nextMessage.role)) {\n result.push({\n role: 'user',\n content: '-',\n } as OpenAI.ChatCompletionMessageParam)\n }\n })\n\n return result\n}\n","import type OpenAI from 'openai'\nimport { alternatingMessages } from '@/lib/messages/alternatingMessages'\n\nexport const post = ({\n perplexity,\n}: {\n perplexity: OpenAI\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n\n const messages = alternatingMessages({\n messages: body.messages,\n })\n\n if (body.stream) {\n const response = await perplexity.chat.completions.create({\n ...body,\n messages,\n })\n\n const stream = new ReadableStream({\n async start(controller) {\n // @ts-ignore-next-line\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await perplexity.chat.completions.create(body)\n\n return new Response(JSON.stringify({\n data,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","import type OpenAI from 'openai'\nimport { post } from './post'\n\nexport const completions = ({\n perplexity,\n}: {\n perplexity: OpenAI\n}) => ({\n post: post({ perplexity }),\n})\n","import type OpenAI from 'openai'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const perplexityClientAdapter = ({\n perplexity,\n}: {\n perplexity: OpenAI\n}) => ({\n client: perplexity,\n requestHandlers: {\n '^/v1/models$': models({ perplexity }),\n '^/v1/chat/completions$': completions({ perplexity }),\n },\n})\n","import type Anthropic from '@anthropic-ai/sdk'\n\nexport const get = ({\n anthropic,\n}: {\n anthropic: Anthropic\n}) => async (_url: string, _options: any) => {\n try {\n const response = await anthropic.models.list()\n\n return new Response(JSON.stringify({\n type: 'list',\n data: response.data.map((model) => ({\n id: model.id,\n object: 'model',\n })),\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type Anthropic from '@anthropic-ai/sdk'\nimport { get } from './get'\n\nexport const models = ({\n anthropic,\n}: {\n anthropic: Anthropic\n}) => ({\n get: get({ anthropic }),\n})\n","import type Anthropic from '@anthropic-ai/sdk'\nimport type OpenAI from 'openai'\nimport { uid, fork, omit, isEmpty } from 'radash'\nimport { nonEmptyMessages } from '@/lib/messages/nonEmptyMessages'\nimport { alternatingMessages } from '@/lib/messages/alternatingMessages'\nimport { firstUserMessages } from '@/lib/messages/firstUserMessages'\nimport { serializeTools } from './serializeTools'\nimport { serializeMessages } from './serializeMessages'\nimport { serializeBetas } from './serializeBetas'\nimport { normalizeComputerToolCallPayload } from '../normalizeComputerToolCallPayload'\n\nexport const post = ({\n anthropic,\n}: {\n anthropic: Anthropic\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n\n const messages = body.messages as OpenAI.ChatCompletionMessageParam[]\n const [systemMessages, otherMessages] = fork(messages, (message) => message.role === 'system')\n const system = systemMessages.map((message) => message.content).join('\\n')\n\n const chatMessages = nonEmptyMessages({\n messages: firstUserMessages({\n messages: alternatingMessages({\n messages: otherMessages,\n }),\n }),\n })\n\n const resultOptions = {\n ...omit(body, ['response_format']),\n model: body.model,\n ...serializeBetas({\n tools: body.tools,\n }),\n stream: body.stream,\n system,\n messages: serializeMessages({\n messages: chatMessages,\n }),\n max_tokens: 4096,\n tools: serializeTools({\n tools: body.tools,\n }),\n }\n\n if (resultOptions.stream) {\n // @ts-ignore-next-line\n const response = await anthropic.beta.messages.create(resultOptions)\n\n const stream = new ReadableStream({\n async start(controller) {\n const blockIndexToToolUseId = new Map<number, string>()\n const toolUseIdToIndex = new Map<string, number>()\n const toolUseIdArgumentBuffer = new Map<string, string>()\n const computerToolUseIds = new Set<string>()\n const normalizedComputerCalls = new Set<string>()\n let nextToolCallIndex = 0\n\n const parseJson = (value: string) => {\n try {\n return JSON.parse(value)\n } catch {\n return undefined\n }\n }\n\n const getOrCreateIndexForToolUseId = (toolUseId?: string) => {\n if (!toolUseId) {\n return 0\n }\n\n if (!toolUseIdToIndex.has(toolUseId)) {\n toolUseIdToIndex.set(toolUseId, nextToolCallIndex++)\n }\n\n return toolUseIdToIndex.get(toolUseId) ?? 0\n }\n\n const assignBlockToToolUse = ({\n blockIndex,\n toolUseId,\n }: {\n blockIndex?: number\n toolUseId?: string\n }) => {\n if (typeof blockIndex === 'number' && toolUseId) {\n blockIndexToToolUseId.set(blockIndex, toolUseId)\n }\n }\n\n const markComputerToolUse = (toolUseId?: string) => {\n if (!toolUseId) return\n\n computerToolUseIds.add(toolUseId)\n normalizedComputerCalls.delete(toolUseId)\n toolUseIdArgumentBuffer.set(toolUseId, '')\n }\n\n const getToolUseIdFromBlock = (block: any) => {\n if (!block \|\| typeof block !== 'object') return undefined\n\n if (typeof block.tool_use_id === 'string') {\n return block.tool_use_id\n }\n\n if (typeof block.id === 'string') {\n return block.id\n }\n\n return undefined\n }\n\n const emitNormalizedToolCall = ({\n normalized,\n toolCallIndex,\n chunkIndex,\n }: {\n normalized: Record<string, unknown>\n toolCallIndex: number\n chunkIndex: number\n }) => {\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [\n {\n index: chunkIndex,\n delta: {\n tool_calls: [\n {\n index: toolCallIndex,\n function: {\n arguments: JSON.stringify(normalized),\n },\n },\n ],\n },\n },\n ],\n }\n\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n }\n\n const getOrCreateIndexForBlock = (blockIndex?: number) => {\n if (typeof blockIndex !== 'number') {\n return 0\n }\n\n const toolUseId = blockIndexToToolUseId.get(blockIndex)\n return getOrCreateIndexForToolUseId(toolUseId)\n }\n\n for await (const chunk of response) {\n if (chunk.type === 'content_block_stop') {\n const toolUseId =\n typeof chunk.index === 'number'\n ? blockIndexToToolUseId.get(chunk.index)\n : undefined\n\n if (toolUseId && computerToolUseIds.has(toolUseId) && !normalizedComputerCalls.has(toolUseId)) {\n const buffered = toolUseIdArgumentBuffer.get(toolUseId) ?? ''\n\n const parsed = buffered ? parseJson(buffered) : undefined\n if (parsed !== undefined) {\n const normalized = normalizeComputerToolCallPayload(parsed)\n const toolCallIndex = getOrCreateIndexForToolUseId(toolUseId)\n const chunkIndex = typeof chunk.index === 'number' ? chunk.index : 0\n\n emitNormalizedToolCall({\n normalized,\n toolCallIndex,\n chunkIndex,\n })\n normalizedComputerCalls.add(toolUseId)\n }\n }\n\n if (toolUseId && !computerToolUseIds.has(toolUseId)) {\n const buffered = toolUseIdArgumentBuffer.get(toolUseId) ?? ''\n if (!buffered.trim()) {\n const toolCallIndex = getOrCreateIndexForToolUseId(toolUseId)\n const chunkIndex = typeof chunk.index === 'number' ? chunk.index : 0\n\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [\n {\n index: chunkIndex,\n delta: {\n content: null,\n tool_calls: [\n {\n index: toolCallIndex,\n function: {\n arguments: '{}',\n },\n },\n ],\n },\n },\n ],\n }\n\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n }\n }\n\n if (toolUseId) {\n toolUseIdArgumentBuffer.delete(toolUseId)\n computerToolUseIds.delete(toolUseId)\n normalizedComputerCalls.delete(toolUseId)\n }\n\n if (typeof chunk.index === 'number') {\n blockIndexToToolUseId.delete(chunk.index)\n }\n\n continue\n }\n\n if (chunk.type === 'content_block_delta') {\n let delta: { tool_calls?: any; content?: string \| null }\n\n if (chunk.delta.type === 'input_json_delta') {\n const toolUseId =\n typeof chunk.index === 'number'\n ? blockIndexToToolUseId.get(chunk.index)\n : undefined\n\n if (toolUseId && computerToolUseIds.has(toolUseId)) {\n const existing = toolUseIdArgumentBuffer.get(toolUseId) ?? ''\n const updated = `${existing}${chunk.delta.partial_json ?? ''}`\n toolUseIdArgumentBuffer.set(toolUseId, updated)\n\n if (!normalizedComputerCalls.has(toolUseId)) {\n const parsed = parseJson(updated)\n if (parsed !== undefined) {\n const normalized = normalizeComputerToolCallPayload(parsed)\n const toolCallIndex = getOrCreateIndexForToolUseId(toolUseId)\n const chunkIndex = typeof chunk.index === 'number' ? chunk.index : 0\n\n emitNormalizedToolCall({\n normalized,\n toolCallIndex,\n chunkIndex,\n })\n normalizedComputerCalls.add(toolUseId)\n }\n }\n\n continue\n }\n\n if (toolUseId) {\n const existing = toolUseIdArgumentBuffer.get(toolUseId) ?? ''\n toolUseIdArgumentBuffer.set(\n toolUseId,\n `${existing}${chunk.delta.partial_json ?? ''}`\n )\n }\n\n const index = getOrCreateIndexForBlock(chunk.index)\n\n delta = {\n tool_calls: [\n {\n index,\n function: {\n arguments: chunk.delta.partial_json,\n },\n },\n ],\n }\n } else if ('text' in chunk.delta) {\n delta = {\n content: chunk.delta.text,\n }\n } else {\n delta = {\n content: '',\n }\n }\n\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [\n {\n index: chunk.index,\n delta,\n },\n ],\n }\n\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n } else if (chunk.type === 'content_block_start') {\n let delta: { content: string \| null; tool_calls?: any }\n\n if (chunk.content_block.type === 'tool_use') {\n const toolName = chunk.content_block.name as string\n const normalizedToolName = toolName === 'computer' ? 'computer_call' : toolName\n const index = getOrCreateIndexForToolUseId(chunk.content_block.id)\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: chunk.content_block.id,\n })\n if (normalizedToolName === 'computer_call') {\n markComputerToolUse(chunk.content_block.id)\n } else if (!toolUseIdArgumentBuffer.has(chunk.content_block.id)) {\n toolUseIdArgumentBuffer.set(chunk.content_block.id, '')\n }\n\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: chunk.content_block.id,\n type: 'function',\n function: {\n name: normalizedToolName,\n arguments: '',\n },\n },\n ],\n }\n } else if (chunk.content_block.type === 'server_tool_use') {\n const index = getOrCreateIndexForToolUseId(chunk.content_block.id)\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: chunk.content_block.id,\n })\n if (!toolUseIdArgumentBuffer.has(chunk.content_block.id)) {\n toolUseIdArgumentBuffer.set(chunk.content_block.id, '')\n }\n\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: chunk.content_block.id,\n type: 'function',\n function: {\n name: chunk.content_block.name as string,\n arguments: '',\n },\n },\n ],\n }\n } else if (chunk.content_block.type === 'web_search_tool_result') {\n const outputPayload = {\n content: chunk.content_block.content ?? [],\n }\n const toolCallId = getToolUseIdFromBlock(chunk.content_block) ?? ''\n const index = getOrCreateIndexForToolUseId(toolCallId)\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: toolCallId,\n })\n\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: toolCallId,\n type: 'function',\n function: {\n output: JSON.stringify(outputPayload),\n },\n },\n ],\n }\n } else if (\n ['code_execution_tool_result', 'bash_code_execution_tool_result', 'python_code_execution_tool_result'].includes(\n (chunk.content_block as any).type\n )\n ) {\n const toolCallId = getToolUseIdFromBlock(chunk.content_block) ?? ''\n\n const {\n tool_use_id: _toolUseId,\n type: _type,\n id: _id,\n ...rest\n } = chunk.content_block as unknown as Record<string, unknown>\n const index = getOrCreateIndexForToolUseId(toolCallId)\n assignBlockToToolUse({\n blockIndex: chunk.index,\n toolUseId: toolCallId,\n })\n\n const outputPayload =\n Object.keys(rest).length > 0\n ? rest\n : {\n content:\n (chunk.content_block as unknown as {\n content?: unknown\n }).content ?? {},\n }\n\n delta = {\n content: null,\n tool_calls: [\n {\n index,\n id: toolCallId,\n type: 'function',\n function: {\n output: JSON.stringify(outputPayload),\n },\n },\n ],\n }\n } else if ('text' in chunk.content_block) {\n delta = {\n content: chunk.content_block.text,\n }\n } else {\n delta = {\n content: '',\n }\n }\n\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [\n {\n index: chunk.index,\n delta,\n },\n ],\n }\n\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n } else if (chunk.type === 'message_start') {\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [\n {\n index: 0,\n delta: {\n content: '',\n },\n },\n ],\n }\n\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n }\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n // @ts-ignore-next-line\n const data = await anthropic.messages.create(resultOptions)\n\n const normalizedContent = Array.isArray(data?.content)\n ? data.content.map((block: any) => {\n if (block?.type === 'tool_use' && block?.name === 'computer') {\n return {\n ...block,\n input: normalizeComputerToolCallPayload(block.input ?? {}),\n }\n }\n\n return block\n })\n : data?.content\n\n const normalizedData = {\n ...data,\n ...(normalizedContent ? { content: normalizedContent } : {}),\n }\n\n return new Response(JSON.stringify({\n data: normalizedData,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","import type OpenAI from 'openai'\n\nconst nonEmptyContent = ({\n message,\n}: {\n message: OpenAI.Chat.ChatCompletionMessageParam\n}): OpenAI.Chat.ChatCompletionMessageParam['content'] => {\n if (message.content == null) {\n return '-'\n }\n\n if (typeof message.content === 'string') {\n if (!/\\S/.test(message.content)) {\n return '-'\n }\n }\n\n return message.content as OpenAI.Chat.ChatCompletionMessageParam[\"content\"]\n}\n\ntype ExtendedRole = OpenAI.Chat.ChatCompletionMessageParam['role'] \| 'developer'\n\ntype ExtendedMessageParam = Omit<OpenAI.Chat.ChatCompletionMessageParam, 'role'> & {\n role: ExtendedRole\n}\n\nexport const nonEmptyMessages = ({\n messages,\n}: {\n messages: OpenAI.Chat.ChatCompletionMessageParam[]\n}) => {\n const result = [] as ExtendedMessageParam[]\n\n messages.forEach((message: OpenAI.Chat.ChatCompletionMessageParam) => (\n result.push({\n ...message,\n content: nonEmptyContent({ message }),\n } as ExtendedMessageParam)\n ))\n\n return result as OpenAI.Chat.ChatCompletionMessageParam[]\n}\n","import type OpenAI from 'openai'\n\nexport const firstUserMessages = ({\n messages,\n}: {\n messages: OpenAI.ChatCompletionMessageParam[]\n}): OpenAI.ChatCompletionMessageParam[] => {\n const firstMessage = messages[0]\n if (!firstMessage) return messages\n\n if (firstMessage.role !== 'user') {\n return [\n {\n role: 'user',\n content: '-',\n } as OpenAI.ChatCompletionMessageParam,\n ...messages,\n ]\n }\n\n return messages\n}\n","import type OpenAI from 'openai'\n\nexport const serializeTools = ({\n tools,\n}: {\n tools: OpenAI.Beta.AssistantTool[] \| undefined\n}) => (\n (tools ?? []).map((tool: OpenAI.Beta.AssistantTool) => {\n if (tool.type === 'function') {\n return {\n name: tool.function.name,\n description: tool.function.description,\n input_schema: tool.function.parameters ?? {\n type: 'object',\n },\n }\n }\n\n return {\n type: tool.type,\n // @ts-ignore-next-line\n ...(tool[tool.type] \|\| {}),\n }\n })\n)\n","import type OpenAI from 'openai'\n\nexport const serializeMessage = ({\n message,\n}: {\n message: OpenAI.ChatCompletionMessageParam\n}) => {\n const parseArguments = (value?: string \| null) => {\n if (typeof value !== 'string') return {}\n const trimmed = value.trim()\n if (!trimmed) return {}\n\n try {\n return JSON.parse(trimmed)\n } catch {\n return {}\n }\n }\n\n if (message.role === 'user') {\n return {\n role: 'user',\n content: message.content,\n }\n } else if (message.role === 'assistant') {\n return {\n role: 'assistant',\n content: [\n {\n type: 'text',\n text: message.content,\n },\n ...(message.tool_calls ?? []).map((toolCall) => ({\n type: 'tool_use',\n id: toolCall.id,\n // @ts-expect-error todo\n name: toolCall.function.name,\n // @ts-expect-error todo\n input: parseArguments(toolCall.function.arguments),\n })),\n ],\n }\n } else if (message.role === 'tool') {\n return {\n role: 'user',\n content: [\n {\n type: 'tool_result',\n tool_use_id: message.tool_call_id,\n content: message.content,\n },\n ],\n }\n }\n}\n","import type OpenAI from 'openai'\nimport { serializeMessage } from './serializeMessage'\n\nexport const serializeMessages = ({\n messages,\n}: {\n messages: OpenAI.ChatCompletionMessageParam[]\n}) => (\n messages.map(message => (\n serializeMessage({\n message,\n })\n ))\n)\n","import type OpenAI from 'openai'\n\ntype AnthropicTool = {\n type: 'computer_20250124' \| 'code_execution_20250825'\n}\n\nexport const serializeBetas = ({\n tools = [],\n}: {\n tools: (OpenAI.Beta.AssistantTool \| AnthropicTool)[] \| undefined\n}) => {\n const betas = []\n\n if (tools.some((tool) => tool.type === 'computer_20250124')) {\n betas.push('computer-use-2025-01-24')\n }\n\n if (tools.some((tool) => tool.type === 'code_execution_20250825')) {\n betas.push('code-execution-2025-08-25')\n }\n\n if (!betas.length) {\n return {}\n }\n\n return {\n betas,\n }\n}\n","import { omit } from 'radash'\n\ntype Coordinates = { x: number; y: number }\n\nconst coordinateKeys = [\n 'coordinate',\n 'coordinates',\n 'coordinate_start',\n 'coordinate_end',\n 'start',\n 'end',\n 'from',\n 'to',\n 'target',\n 'point',\n 'position',\n 'cursor_position',\n 'path',\n]\n\nconst clickButtonMap: Record<string, 'left' \| 'right' \| 'wheel' \| 'back' \| 'forward'> = {\n left_click: 'left',\n right_click: 'right',\n middle_click: 'wheel',\n double_click: 'left',\n triple_click: 'left',\n left_mouse_down: 'left',\n left_mouse_up: 'left',\n}\n\nconst keyAliasMap: Record<string, string> = {\n ctrl: 'ctrl',\n control: 'ctrl',\n cmd: 'meta',\n command: 'meta',\n meta: 'meta',\n win: 'meta',\n option: 'alt',\n alt: 'alt',\n shift: 'shift',\n enter: 'enter',\n return: 'enter',\n esc: 'escape',\n escape: 'escape',\n tab: 'tab',\n space: 'space',\n spacebar: 'space',\n backspace: 'backspace',\n del: 'delete',\n delete: 'delete',\n pageup: 'pageup',\n pagedown: 'pagedown',\n up: 'up',\n down: 'down',\n left: 'left',\n right: 'right',\n}\n\nconst sanitizeNumber = (value: unknown) => (typeof value === 'number' ? value : undefined)\n\nconst toCoordinate = (value: unknown): Coordinates \| undefined => {\n if (!value) return undefined\n\n if (Array.isArray(value)) {\n if (value.length === 2 && typeof value[0] === 'number' && typeof value[1] === 'number') {\n return { x: value[0], y: value[1] }\n }\n\n if (value.length > 0 && Array.isArray(value[0])) {\n const tuple = value[0]\n if (tuple.length === 2 && typeof tuple[0] === 'number' && typeof tuple[1] === 'number') {\n return { x: tuple[0], y: tuple[1] }\n }\n }\n }\n\n if (typeof value === 'object') {\n const maybe = value as Record<string, unknown>\n const x = sanitizeNumber(maybe.x)\n const y = sanitizeNumber(maybe.y)\n if (typeof x === 'number' && typeof y === 'number') {\n return { x, y }\n }\n }\n\n if (typeof value === 'string') {\n const parts = value.split(/[, ]+/).map(Number).filter(Number.isFinite)\n if (parts.length >= 2) {\n return { x: parts[0], y: parts[1] }\n }\n }\n\n return undefined\n}\n\nconst findCoordinatesInDetails = (details: Record<string, unknown>) => {\n for (const key of coordinateKeys) {\n const value = details[key]\n const coords = toCoordinate(value)\n if (coords) {\n return coords\n }\n }\n\n return undefined\n}\n\nconst buildDragPath = (details: Record<string, unknown>): Coordinates[] => {\n const path: Coordinates[] = []\n\n if (Array.isArray(details.path)) {\n for (const point of details.path) {\n const coords = toCoordinate(point)\n if (coords) {\n path.push(coords)\n }\n }\n }\n\n if (!path.length) {\n const start =\n toCoordinate(details.coordinate_start) \|\|\n toCoordinate(details.start) \|\|\n toCoordinate(details.from)\n if (start) {\n path.push(start)\n }\n\n const end =\n toCoordinate(details.coordinate_end) \|\|\n toCoordinate(details.end) \|\|\n toCoordinate(details.to) \|\|\n toCoordinate(details.target)\n if (end) {\n path.push(end)\n }\n }\n\n if (!path.length) {\n const coords = findCoordinatesInDetails(details)\n if (coords) {\n path.push(coords)\n }\n }\n\n if (!path.length) {\n path.push({ x: 0, y: 0 })\n }\n\n return path\n}\n\nconst parseKeys = (input: unknown): string[] => {\n if (Array.isArray(input)) {\n return input.map(String).map((key) => key.trim()).filter(Boolean)\n }\n\n if (typeof input === 'string') {\n return input\n .split(/(?:(?<!\\\\)\\+\|\\s+)/)\n .map((key) => key.replace(/\\\\\\+/g, '+'))\n .map((key) => key.trim())\n .filter(Boolean)\n }\n\n return []\n}\n\nconst normalizeKeys = (keys: string[]): string[] => {\n return keys.map((key) => {\n const lowerKey = key.toLowerCase()\n return keyAliasMap[lowerKey] ?? lowerKey\n })\n}\n\nconst normalizeScroll = (details: Record<string, unknown>) => {\n let scrollX = sanitizeNumber(details.scroll_x) ?? 0\n let scrollY = sanitizeNumber(details.scroll_y) ?? 0\n const amount =\n sanitizeNumber(details.scroll_amount) ??\n sanitizeNumber(details.amount) ??\n 0\n\n const direction = typeof details.scroll_direction === 'string'\n ? details.scroll_direction.toLowerCase()\n : typeof details.direction === 'string'\n ? details.direction.toLowerCase()\n : undefined\n\n if (!scrollX && !scrollY && direction && amount) {\n switch (direction) {\n case 'up':\n scrollY = -amount\n break\n case 'down':\n scrollY = amount\n break\n case 'left':\n scrollX = -amount\n break\n case 'right':\n scrollX = amount\n break\n default:\n break\n }\n }\n\n return { scroll_x: scrollX, scroll_y: scrollY }\n}\n\nconst normalizeActionString = (\n action: string,\n details: Record<string, unknown>,\n): Record<string, unknown> => {\n const coords = findCoordinatesInDetails(details)\n\n switch (action) {\n case 'screenshot':\n return { type: 'screenshot' }\n case 'left_click':\n case 'right_click':\n case 'middle_click': {\n return {\n type: 'click',\n button: clickButtonMap[action],\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n }\n }\n case 'double_click':\n return {\n type: 'double_click',\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n }\n case 'triple_click':\n return {\n type: 'double_click',\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n repetitions: 3,\n }\n case 'left_mouse_down':\n return {\n type: 'click',\n button: clickButtonMap[action],\n state: 'down',\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n }\n case 'left_mouse_up':\n return {\n type: 'click',\n button: clickButtonMap[action],\n state: 'up',\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n }\n case 'left_click_drag': {\n const path = buildDragPath(details).map(({ x, y }) => ({ x, y }))\n return {\n type: 'drag',\n path,\n }\n }\n case 'mouse_move':\n case 'cursor_position':\n return {\n type: 'move',\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n }\n case 'scroll': {\n const { scroll_x, scroll_y } = normalizeScroll(details)\n return {\n type: 'scroll',\n x: coords?.x ?? 0,\n y: coords?.y ?? 0,\n scroll_x,\n scroll_y,\n ...(typeof details.scroll_direction === 'string'\n ? { direction: details.scroll_direction }\n : typeof details.direction === 'string'\n ? { direction: details.direction }\n : {}),\n ...(typeof details.scroll_amount === 'number'\n ? { amount: details.scroll_amount }\n : typeof details.amount === 'number'\n ? { amount: details.amount }\n : {}),\n }\n }\n case 'type': {\n const text =\n typeof details.text === 'string'\n ? details.text\n : typeof details.input === 'string'\n ? details.input\n : ''\n return {\n type: 'type',\n text,\n }\n }\n case 'key':\n case 'hold_key': {\n const keys = normalizeKeys(\n parseKeys(details.text ?? details.keys ?? details.key),\n )\n const normalized: Record<string, unknown> = {\n type: 'keypress',\n keys,\n }\n\n if (action === 'hold_key') {\n const duration = sanitizeNumber(details.duration)\n if (typeof duration === 'number') {\n normalized.hold_duration_ms = Math.round(duration 1000)\n }\n }\n\n return normalized\n }\n case 'wait': {\n const duration = sanitizeNumber(details.duration)\n return {\n type: 'wait',\n ...(typeof duration === 'number'\n ? { duration_ms: Math.round(duration * 1000) }\n : {}),\n }\n }\n default: {\n return {\n type: action,\n ...(coords ? { x: coords.x, y: coords.y } : {}),\n ...omit(details, [\n ...coordinateKeys,\n 'text',\n 'scroll_direction',\n 'direction',\n 'scroll_amount',\n 'amount',\n 'scroll_x',\n 'scroll_y',\n 'keys',\n 'duration',\n ]),\n }\n }\n }\n}\n\nconst normalizeAction = (payload: any): Record<string, unknown> => {\n if (payload && typeof payload === 'object') {\n let rawAction = (payload as any).action\n\n if (typeof rawAction === 'string') {\n const parsedAction = parseJson(rawAction)\n if (parsedAction && typeof parsedAction === 'object') {\n rawAction = parsedAction\n }\n }\n\n if (rawAction && typeof rawAction === 'object' && typeof rawAction.type === 'string') {\n return rawAction as Record<string, unknown>\n }\n\n if (typeof rawAction === 'string') {\n const details = omit(payload, ['action', 'pending_safety_checks', 'status'])\n return normalizeActionString(rawAction, details)\n }\n\n if (typeof (payload as any).type === 'string') {\n return payload as Record<string, unknown>\n }\n }\n\n if (typeof payload === 'string') {\n const parsed = parseJson(payload)\n if (parsed && typeof parsed === 'object') {\n return normalizeAction(parsed)\n }\n\n return { type: payload }\n }\n\n return {\n type: 'unknown',\n value: payload,\n }\n}\n\nexport const normalizeComputerToolCallPayload = (payload: any) => {\n let normalizedPayload = payload\n if (typeof payload === 'string') {\n const parsed = parseJson(payload)\n if (parsed !== undefined) {\n normalizedPayload = parsed\n }\n }\n\n let pendingSafetyChecksRaw =\n normalizedPayload && typeof normalizedPayload === 'object'\n ? (normalizedPayload as any).pending_safety_checks\n : undefined\n\n if (typeof pendingSafetyChecksRaw === 'string') {\n const parsed = parseJson(pendingSafetyChecksRaw)\n pendingSafetyChecksRaw = Array.isArray(parsed) ? parsed : []\n }\n\n const pendingSafetyChecks = Array.isArray(pendingSafetyChecksRaw)\n ? pendingSafetyChecksRaw\n : []\n\n const normalizedAction = normalizeAction(normalizedPayload)\n\n const result: {\n action: Record<string, unknown>\n pending_safety_checks: unknown[]\n status?: unknown\n } = {\n action: normalizedAction,\n pending_safety_checks: pendingSafetyChecks,\n }\n\n if (normalizedPayload && typeof normalizedPayload === 'object' && 'status' in normalizedPayload) {\n result.status = (normalizedPayload as any).status\n }\n\n return result\n}\nconst parseJson = (value: string) => {\n try {\n return JSON.parse(value)\n } catch {\n return undefined\n }\n}\n","import type Anthropic from '@anthropic-ai/sdk'\nimport { post } from './post'\n\nexport const completions = ({\n anthropic,\n}: {\n anthropic: Anthropic\n}) => ({\n post: post({ anthropic }),\n})\n","import type Anthropic from '@anthropic-ai/sdk'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const anthropicClientAdapter = ({\n anthropic,\n}: {\n anthropic: Anthropic\n}) => ({\n client: anthropic,\n requestHandlers: {\n '^/v1/models$': models({ anthropic }),\n '^/v1/chat/completions$': completions({ anthropic }),\n },\n})\n","import type OpenAI from 'openai'\n\nexport const get = ({\n together,\n}: {\n together: OpenAI\n}) => async (_url: string, _options: any) => {\n try {\n const data = await together.models.list()\n\n return new Response(JSON.stringify({\n type: 'list',\n // @ts-ignore-next-line\n data: data.body,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type OpenAI from 'openai'\nimport { get } from './get'\n\nexport const models = ({\n together,\n}: {\n together: OpenAI\n}) => ({\n get: get({ together }),\n})\n","import type OpenAI from 'openai'\n\nexport const post = ({\n together,\n}: {\n together: OpenAI\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n\n if (body.stream) {\n const response = await together.chat.completions.create(body)\n\n const stream = new ReadableStream({\n async start(controller) {\n // @ts-ignore-next-line\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await together.chat.completions.create(body)\n\n return new Response(JSON.stringify({\n data,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","import type OpenAI from 'openai'\nimport { post } from './post'\n\nexport const completions = ({\n together,\n}: {\n together: OpenAI\n}) => ({\n post: post({ together }),\n})\n","import type OpenAI from 'openai'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const togetherClientAdapter = ({\n together,\n}: {\n together: OpenAI\n}) => ({\n client: together,\n requestHandlers: {\n '^/v1/models$': models({ together }),\n '^/(?:v1\|/?openai)/chat/completions$': completions({ together }),\n },\n})\n","import type { GoogleGenAI } from '@google/genai'\n\nexport const get = ({\n google,\n}: {\n google: GoogleGenAI\n}) => async (_url: string, _options: any) => {\n try {\n const pager = await google.models.list()\n\n return new Response(JSON.stringify({\n type: 'list',\n data: pager.page.map((model) => ({\n id: model.name ?? '',\n object: 'model',\n })),\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type { GoogleGenAI } from '@google/genai'\nimport { get } from './get'\n\nexport const models = ({\n google,\n}: {\n google: GoogleGenAI\n}) => ({\n get: get({ google }),\n})\n","import type { GoogleGenAI, Content, Part, Tool, FunctionResponsePart } from '@google/genai'\nimport { createId } from '@paralleldrive/cuid2'\nimport { uid } from 'radash'\nimport { nonEmptyMessages } from '@/lib/messages/nonEmptyMessages'\nimport { normalizeComputerToolCallPayload } from '../../anthropicClientAdapter/normalizeComputerToolCallPayload'\nimport { normalizeGeminiAction, isGeminiAction } from '../normalizeGeminiAction'\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/** Strip the `default_api:` prefix Gemini adds to computer-use function names /\nconst stripFunctionPrefix = (name: string) => name.replace(/^default_api:/, '')\n\n/* Collect user-defined function names from OpenAI-format tools /\nconst getUserDefinedFunctionNames = (tools: any[] \| undefined): Set<string> => {\n const names = new Set<string>()\n if (!tools) return names\n for (const t of tools) {\n if (t.type === 'function' && t.function?.name) {\n names.add(t.function.name)\n }\n }\n return names\n}\n\nconst hasComputerUseTool = (tools: any[] \| undefined): boolean =>\n !!tools?.some((t: any) => t.type === 'computer_use_preview')\n\n// ---------------------------------------------------------------------------\n// OpenAI → Gemini message conversion\n// ---------------------------------------------------------------------------\n\nexport const serializeMessages = (messages: any[]): { contents: Content[]; systemInstruction?: string } => {\n const systemParts: string[] = []\n const contents: Content[] = []\n // Track tool_call_id → function name for tool responses\n const toolCallIdToName = new Map<string, string>()\n\n // Compound sub-action tracking for round-trip serialization\n const geminiCallGroups = new Map<string, { name: string; primaryId: string }>()\n const skipToolResultIds = new Set<string>()\n const lastSubActionMap = new Map<string, string>() // last sub-action tool_call_id → geminiCallId\n\n for (const msg of messages) {\n if (msg.role === 'system' \|\| msg.role === 'developer') {\n systemParts.push(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content))\n continue\n }\n\n if (msg.role === 'user') {\n const parts: Part[] = []\n\n if (typeof msg.content === 'string') {\n parts.push({ text: msg.content })\n } else if (Array.isArray(msg.content)) {\n for (const part of msg.content) {\n if (part.type === 'text') {\n parts.push({ text: part.text })\n } else if (part.type === 'image_url') {\n const url: string = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url\n if (url?.startsWith('data:')) {\n const match = url.match(/^data:([^;]+);base64,(.+)$/)\n if (match) {\n parts.push({ inlineData: { mimeType: match[1], data: match[2] } })\n }\n } else if (url) {\n parts.push({ fileData: { fileUri: url, mimeType: 'image/png' } })\n }\n }\n }\n }\n\n if (parts.length > 0) {\n contents.push({ role: 'user', parts })\n }\n continue\n }\n\n if (msg.role === 'assistant') {\n const parts: Part[] = []\n\n if (msg.content) {\n const text = typeof msg.content === 'string' ? msg.content : ''\n if (text) {\n parts.push({ text })\n }\n }\n\n if (msg.tool_calls) {\n for (const tc of msg.tool_calls) {\n const name = tc.function?.name ?? ''\n const id = tc.id ?? `call_${createId()}`\n let args: Record<string, unknown> = {}\n try {\n args = JSON.parse(tc.function?.arguments ?? '{}')\n } catch {}\n\n // Extract private fields stashed by our streaming handler\n const thoughtSignature = args._thoughtSignature as string \| undefined\n const geminiActionName = args._geminiAction as string \| undefined\n const geminiCallId = args._geminiCallId as string \| undefined\n const subActionIndex = args._subActionIndex as number \| undefined\n const subActionTotal = args._subActionTotal as number \| undefined\n const geminiOrigArgs = args._geminiArgs as Record<string, unknown> \| undefined\n const cleanArgs = { ...args }\n delete cleanArgs._thoughtSignature\n delete cleanArgs._geminiAction\n delete cleanArgs._geminiCallId\n delete cleanArgs._subActionIndex\n delete cleanArgs._subActionTotal\n delete cleanArgs._geminiArgs\n\n // Handle compound sub-actions (multiple tool calls from one Gemini function)\n if (geminiCallId && typeof subActionIndex === 'number' && typeof subActionTotal === 'number') {\n if (subActionIndex === 0) {\n // Primary: create one functionCall for the original Gemini action\n const fcName = geminiActionName ?? name\n geminiCallGroups.set(geminiCallId, { name: fcName, primaryId: id })\n toolCallIdToName.set(id, fcName)\n if (subActionTotal > 1) skipToolResultIds.add(id)\n\n const fcPart: Part = { functionCall: { name: fcName, args: geminiOrigArgs ?? {}, id } }\n if (thoughtSignature) (fcPart as any).thoughtSignature = thoughtSignature\n parts.push(fcPart)\n } else if (subActionIndex === subActionTotal - 1) {\n // Last: its tool result maps back to the group\n lastSubActionMap.set(id, geminiCallId)\n } else {\n // Middle: skip functionCall and tool result\n skipToolResultIds.add(id)\n }\n continue\n }\n\n // Normal (non-compound) tool call\n let geminiName = name\n if (name === 'computer_call' && args.action && typeof args.action === 'object') {\n geminiName = geminiActionName ?? (args.action as any).type ?? name\n }\n\n let geminiArgs: Record<string, unknown>\n if (name === 'computer_call' && cleanArgs.action && typeof cleanArgs.action === 'object') {\n const action = cleanArgs.action as Record<string, unknown>\n const { type: _type, ...rest } = action\n geminiArgs = rest\n } else {\n geminiArgs = cleanArgs\n }\n\n toolCallIdToName.set(id, geminiName)\n\n const fcPart: Part = { functionCall: { name: geminiName, args: geminiArgs, id } }\n if (thoughtSignature) {\n (fcPart as any).thoughtSignature = thoughtSignature\n }\n parts.push(fcPart)\n }\n }\n\n if (parts.length > 0) {\n contents.push({ role: 'model', parts })\n }\n continue\n }\n\n if (msg.role === 'tool') {\n const toolCallId = msg.tool_call_id ?? ''\n\n // Skip tool results for non-last compound sub-actions\n if (skipToolResultIds.has(toolCallId)) continue\n\n // Determine name and ID — remap last sub-action to original Gemini call\n let responseName: string\n let responseId: string\n if (lastSubActionMap.has(toolCallId)) {\n const gcId = lastSubActionMap.get(toolCallId)!\n const group = geminiCallGroups.get(gcId)!\n responseName = group.name\n responseId = group.primaryId\n } else {\n responseName = toolCallIdToName.get(toolCallId) ?? ''\n responseId = toolCallId\n }\n\n const parts: Part[] = []\n\n // Check for image content (screenshots from computer use)\n const imageContent = extractImageFromToolMessage(msg)\n\n if (imageContent) {\n const responseParts: FunctionResponsePart[] = [{\n inlineData: {\n mimeType: imageContent.mimeType,\n data: imageContent.data,\n },\n }]\n parts.push({\n functionResponse: {\n id: responseId,\n name: responseName,\n response: { output: 'Screenshot captured.' },\n parts: responseParts,\n },\n })\n } else {\n const output = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)\n parts.push({\n functionResponse: {\n id: responseId,\n name: responseName,\n response: { output },\n },\n })\n }\n\n // Merge consecutive tool responses into a single user turn\n const lastContent = contents[contents.length - 1]\n if (lastContent && lastContent.role === 'user' && lastContent.parts?.some((p) => p.functionResponse)) {\n lastContent.parts!.push(...parts)\n } else {\n contents.push({ role: 'user', parts })\n }\n continue\n }\n }\n\n return {\n contents,\n ...(systemParts.length > 0 ? { systemInstruction: systemParts.join('\\n') } : {}),\n }\n}\n\n// ---------------------------------------------------------------------------\n// Extract base64 image data from a tool message (computer_screenshot output)\n// ---------------------------------------------------------------------------\n\nconst extractImageFromToolMessage = (msg: any): { mimeType: string; data: string } \| null => {\n const content = msg.content\n\n // Content array with image_url parts\n if (Array.isArray(content)) {\n for (const part of content) {\n if (part.type === 'image_url') {\n const url = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url\n return parseDataUri(url)\n }\n }\n return null\n }\n\n // String content — try parsing as JSON with computer_screenshot\n if (typeof content === 'string') {\n try {\n const parsed = JSON.parse(content)\n if (parsed.type === 'computer_screenshot' && parsed.image_url) {\n return parseDataUri(parsed.image_url)\n }\n } catch {}\n }\n\n return null\n}\n\nconst parseDataUri = (url: string \| undefined): { mimeType: string; data: string } \| null => {\n if (!url) return null\n const match = url.match(/^data:([^;]+);base64,(.+)$/)\n if (!match) return null\n return { mimeType: match[1], data: match[2] }\n}\n\n// ---------------------------------------------------------------------------\n// OpenAI tools → Gemini tools\n// ---------------------------------------------------------------------------\n\nconst serializeTools = (tools: any[] \| undefined): Tool[] => {\n if (!tools \|\| tools.length === 0) return []\n\n const geminiTools: Tool[] = []\n const functionDeclarations: any[] = []\n let computerUseEnabled = false\n\n for (const tool of tools) {\n if (tool.type === 'computer_use_preview') {\n computerUseEnabled = true\n continue\n }\n\n if (tool.type === 'function') {\n const fn = tool.function\n if (!fn) continue\n\n const decl: any = {\n name: fn.name,\n }\n if (fn.description) {\n decl.description = fn.description\n }\n if (fn.parameters) {\n decl.parameters = fn.parameters\n }\n functionDeclarations.push(decl)\n }\n }\n\n if (computerUseEnabled) {\n geminiTools.push({\n computerUse: {\n environment: 'ENVIRONMENT_BROWSER' as any,\n excludedPredefinedFunctions: [\n 'navigate',\n 'go_back',\n 'go_forward',\n 'search',\n 'open_web_browser',\n ],\n } as any,\n })\n }\n\n if (functionDeclarations.length > 0) {\n geminiTools.push({ functionDeclarations })\n }\n\n return geminiTools\n}\n\n// ---------------------------------------------------------------------------\n// Gemini coordinate denormalization (0–1000 → pixel coords)\n// ---------------------------------------------------------------------------\n\nconst denormalizeCoords = (\n args: Record<string, unknown>,\n tools: any[] \| undefined,\n): Record<string, unknown> => {\n const computerTool = tools?.find((t: any) => t.type === 'computer_use_preview')\n if (!computerTool) return args\n\n const displayWidth = computerTool.computer_use_preview?.display_width ?? 1280\n const displayHeight = computerTool.computer_use_preview?.display_height ?? 720\n\n const result = { ...args }\n\n const denormX = (v: number) => Math.round((v / 1000) displayWidth)\n const denormY = (v: number) => Math.round((v / 1000) * displayHeight)\n\n if (typeof result.x === 'number') result.x = denormX(result.x)\n if (typeof result.y === 'number') result.y = denormY(result.y)\n\n if (typeof result.coordinate_x === 'number') result.coordinate_x = denormX(result.coordinate_x)\n if (typeof result.coordinate_y === 'number') result.coordinate_y = denormY(result.coordinate_y)\n\n if (Array.isArray(result.coordinate) && result.coordinate.length === 2) {\n result.coordinate = [denormX(result.coordinate[0]), denormY(result.coordinate[1])]\n }\n\n if (Array.isArray(result.start_coordinate) && result.start_coordinate.length === 2) {\n result.start_coordinate = [denormX(result.start_coordinate[0]), denormY(result.start_coordinate[1])]\n }\n if (Array.isArray(result.end_coordinate) && result.end_coordinate.length === 2) {\n result.end_coordinate = [denormX(result.end_coordinate[0]), denormY(result.end_coordinate[1])]\n }\n\n if (typeof result.destination_x === 'number') result.destination_x = denormX(result.destination_x)\n if (typeof result.destination_y === 'number') result.destination_y = denormY(result.destination_y)\n\n return result\n}\n\n// ---------------------------------------------------------------------------\n// Gemini FunctionCall → OpenAI tool_calls delta (with computer_call wrapping)\n// ---------------------------------------------------------------------------\n\n/*\n Determine whether a function call is a Gemini computer-use action.\n * Any function not explicitly declared by the user is treated as\n * a computer-use action when computerUse tool is enabled.\n /\nconst isComputerUseFunction = (\n name: string,\n tools: any[] \| undefined,\n): boolean => {\n if (!hasComputerUseTool(tools)) return false\n const userFns = getUserDefinedFunctionNames(tools)\n return !userFns.has(name)\n}\n\nconst functionCallToToolCallDeltas = (\n fc: any,\n startIndex: number,\n tools: any[] \| undefined,\n thoughtSignature?: string,\n): any[] => {\n const rawName: string = fc.name ?? ''\n const name = stripFunctionPrefix(rawName)\n\n if (isComputerUseFunction(name, tools)) {\n const denormed = denormalizeCoords(fc.args ?? {}, tools)\n\n if (isGeminiAction(name)) {\n const normalizedActions = normalizeGeminiAction(name, denormed)\n\n if (normalizedActions.length === 1) {\n // Single action — simple metadata\n const payload: Record<string, unknown> = { ...normalizedActions[0] }\n payload._geminiAction = name\n if (thoughtSignature) payload._thoughtSignature = thoughtSignature\n\n return [{\n index: startIndex,\n id: fc.id ?? `call_${createId()}`,\n type: 'function',\n function: {\n name: 'computer_call',\n arguments: JSON.stringify(payload),\n },\n }]\n }\n\n // Compound action — emit multiple tool calls with grouping metadata\n const geminiCallId = `gcall_${createId()}`\n return normalizedActions.map((normalized, i) => {\n const payload: Record<string, unknown> = { ...normalized }\n payload._geminiCallId = geminiCallId\n payload._geminiAction = name\n payload._subActionIndex = i\n payload._subActionTotal = normalizedActions.length\n if (i === 0) {\n payload._geminiArgs = denormed\n if (thoughtSignature) payload._thoughtSignature = thoughtSignature\n }\n\n return {\n index: startIndex + i,\n id: i === 0 ? (fc.id ?? `call_${createId()}`) : `call_${createId()}`,\n type: 'function',\n function: {\n name: 'computer_call',\n arguments: JSON.stringify(payload),\n },\n }\n })\n }\n\n // Non-Gemini computer use — use Anthropic normalizer\n const normalized = normalizeComputerToolCallPayload({ ...denormed, type: name })\n const payload: Record<string, unknown> = { ...normalized }\n if (thoughtSignature) payload._thoughtSignature = thoughtSignature\n\n return [{\n index: startIndex,\n id: fc.id ?? `call_${createId()}`,\n type: 'function',\n function: {\n name: 'computer_call',\n arguments: JSON.stringify(payload),\n },\n }]\n }\n\n const args = fc.args ?? {}\n if (thoughtSignature) {\n args._thoughtSignature = thoughtSignature\n }\n\n return [{\n index: startIndex,\n id: fc.id ?? `call_${createId()}`,\n type: 'function',\n function: {\n name,\n arguments: JSON.stringify(args),\n },\n }]\n}\n\n// ---------------------------------------------------------------------------\n// Main handler\n// ---------------------------------------------------------------------------\n\n// ---------------------------------------------------------------------------\n// Synthetic response for pending compound sub-actions\n// ---------------------------------------------------------------------------\n\nconst syntheticToolCallResponse = (toolCallDelta: any, stream: boolean) => {\n // Reset index to 0 since this is the only tool call in the response\n const delta = { ...toolCallDelta, index: 0 }\n const encoder = new TextEncoder()\n\n if (stream) {\n const chunks = [\n `data: ${JSON.stringify({\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [{\n index: 0,\n delta: { content: null, tool_calls: [delta] },\n }],\n })}\\n\\n`,\n `data: ${JSON.stringify({\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [{\n index: 0,\n delta: {},\n finish_reason: 'stop',\n }],\n })}\\n\\n`,\n ]\n\n return new Response(\n new ReadableStream({\n start(controller) {\n for (const chunk of chunks) controller.enqueue(encoder.encode(chunk))\n controller.close()\n },\n }),\n { headers: { 'Content-Type': 'text/event-stream' } },\n )\n }\n\n return new Response(JSON.stringify({\n data: {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion',\n choices: [{\n index: 0,\n message: {\n role: 'assistant',\n content: null,\n tool_calls: [delta],\n },\n finish_reason: 'stop',\n }],\n },\n }), {\n status: 200,\n headers: { 'Content-Type': 'application/json' },\n })\n}\n\nexport const post = ({\n google,\n}: {\n google: GoogleGenAI\n}) => {\n // Queued sub-actions for compound Gemini actions (e.g. type_text_at)\n // Emitted one at a time so superinterface executes them sequentially\n let pendingSubActions: any[] = []\n\n return async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n\n // If there are pending sub-actions, return the next one without calling the model\n if (pendingSubActions.length > 0) {\n const next = pendingSubActions.shift()!\n return syntheticToolCallResponse(next, !!body.stream)\n }\n\n const messages = nonEmptyMessages({ messages: body.messages })\n const { contents, systemInstruction } = serializeMessages(messages)\n const geminiTools = serializeTools(body.tools)\n\n const params: any = {\n model: body.model,\n contents,\n config: {\n ...(systemInstruction ? { systemInstruction } : {}),\n ...(geminiTools.length > 0 ? { tools: geminiTools } : {}),\n ...(typeof body.temperature === 'number' ? { temperature: body.temperature } : {}),\n ...(typeof body.top_p === 'number' ? { topP: body.top_p } : {}),\n ...(typeof body.max_tokens === 'number' ? { maxOutputTokens: body.max_tokens } : {}),\n },\n }\n\n if (body.stream) {\n const response = await google.models.generateContentStream(params)\n\n const stream = new ReadableStream({\n async start(controller) {\n let chunkIndex = 0\n let lastThoughtSignature: string \| undefined\n\n for await (const chunk of response) {\n const candidate = chunk.candidates?.[0]\n if (!candidate?.content?.parts) continue\n\n for (const part of candidate.content.parts) {\n // Capture thought signatures — may be on a separate part or\n // on the same part as a functionCall\n if (part.thoughtSignature) {\n lastThoughtSignature = part.thoughtSignature\n }\n\n // Skip thought-only parts (internal model reasoning)\n if (part.thought && !part.functionCall) continue\n\n if (part.text !== undefined && part.text !== null && !part.thought) {\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [{\n index: 0,\n delta: { content: part.text },\n }],\n }\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n }\n\n if (part.functionCall) {\n const deltas = functionCallToToolCallDeltas(\n part.functionCall,\n chunkIndex,\n body.tools,\n lastThoughtSignature,\n )\n\n // For compound actions, only emit the first sub-action;\n // queue the rest for sequential execution\n const emitDeltas = deltas.length > 1 ? [deltas[0]] : deltas\n if (deltas.length > 1) {\n pendingSubActions.push(...deltas.slice(1))\n }\n\n for (const toolCallDelta of emitDeltas) {\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [{\n index: 0,\n delta: {\n content: null,\n tool_calls: [toolCallDelta],\n },\n }],\n }\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n }\n chunkIndex += emitDeltas.length\n lastThoughtSignature = undefined\n }\n }\n\n // Emit finish reason if present\n if (candidate.finishReason) {\n const messageDelta = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion.chunk',\n choices: [{\n index: 0,\n delta: {},\n finish_reason: 'stop',\n }],\n }\n controller.enqueue(`data: ${JSON.stringify(messageDelta)}\\n\\n`)\n }\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await google.models.generateContent(params)\n\n const candidate = data.candidates?.[0]\n const parts = candidate?.content?.parts ?? []\n\n const textParts = parts.filter((p) => p.text && !p.thought).map((p) => p.text).join('')\n\n // Collect thought signatures to attach to function calls\n // Signature can be on the same part as functionCall or a preceding part\n let lastSig: string \| undefined\n const toolCalls: any[] = []\n for (const p of parts) {\n if (p.thoughtSignature) {\n lastSig = p.thoughtSignature\n }\n if (p.functionCall) {\n const deltas = functionCallToToolCallDeltas(\n p.functionCall,\n toolCalls.length,\n body.tools,\n lastSig,\n )\n\n // For compound actions, only include the first sub-action;\n // queue the rest for sequential execution\n if (deltas.length > 1) {\n toolCalls.push(deltas[0])\n pendingSubActions.push(...deltas.slice(1))\n } else {\n toolCalls.push(...deltas)\n }\n lastSig = undefined\n }\n }\n\n const message: any = {\n role: 'assistant',\n content: textParts \|\| null,\n }\n if (toolCalls.length > 0) {\n message.tool_calls = toolCalls\n }\n\n const result = {\n id: `chatcmpl-${uid(29)}`,\n object: 'chat.completion',\n choices: [{\n index: 0,\n message,\n finish_reason: 'stop',\n }],\n }\n\n return new Response(JSON.stringify({\n data: result,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n }\n}\n","// Known Gemini computer-use action names\nconst GEMINI_ACTION_NAMES = new Set([\n 'click_at', 'single_click_at', 'right_click_at', 'double_click_at', 'triple_click_at',\n 'hover_at', 'type_text_at', 'key_combination', 'scroll_at', 'scroll_document',\n 'drag_and_drop', 'wait_5_seconds', 'wait_for_load',\n])\n\nexport const isGeminiAction = (name: string) => GEMINI_ACTION_NAMES.has(name)\n\ntype NormalizedAction = { action: Record<string, unknown>; pending_safety_checks: unknown[] }\n\nconst act = (action: Record<string, unknown>): NormalizedAction => ({\n action,\n pending_safety_checks: [],\n})\n\nconst normalizeGeminiKey = (key: string): string => {\n const lower = key.toLowerCase()\n switch (lower) {\n case 'control': return 'ctrl'\n case 'command': case 'cmd': return 'meta'\n case 'option': return 'alt'\n default: return lower\n }\n}\n\nconst scrollFromDirection = (\n direction: string \| undefined,\n amount: number,\n): { scroll_x: number; scroll_y: number } => {\n if (!direction) return { scroll_x: 0, scroll_y: 0 }\n switch (direction.toLowerCase()) {\n case 'up': return { scroll_x: 0, scroll_y: -amount }\n case 'down': return { scroll_x: 0, scroll_y: amount }\n case 'left': return { scroll_x: -amount, scroll_y: 0 }\n case 'right': return { scroll_x: amount, scroll_y: 0 }\n default: return { scroll_x: 0, scroll_y: 0 }\n }\n}\n\nexport const normalizeGeminiAction = (\n name: string,\n args: Record<string, unknown>,\n): NormalizedAction[] => {\n const x = typeof args.x === 'number' ? args.x\n : typeof args.coordinate_x === 'number' ? args.coordinate_x\n : 0\n const y = typeof args.y === 'number' ? args.y\n : typeof args.coordinate_y === 'number' ? args.coordinate_y\n : 0\n\n switch (name) {\n case 'click_at':\n case 'single_click_at':\n return [act({ type: 'click', button: 'left', x, y })]\n\n case 'right_click_at':\n return [act({ type: 'click', button: 'right', x, y })]\n\n case 'double_click_at':\n return [act({ type: 'double_click', x, y })]\n\n case 'triple_click_at':\n return [act({ type: 'double_click', x, y, repetitions: 3 })]\n\n case 'hover_at':\n return [act({ type: 'move', x, y })]\n\n case 'type_text_at': {\n const text = typeof args.text === 'string' ? args.text : ''\n const clearBeforeTyping = args.clear_before_typing !== false\n const pressEnter = args.press_enter !== false\n const actions: NormalizedAction[] = [\n act({ type: 'click', button: 'left', x, y }),\n ]\n if (clearBeforeTyping) {\n actions.push(act({ type: 'keypress', keys: ['ctrl', 'a'] }))\n actions.push(act({ type: 'keypress', keys: ['Backspace'] }))\n }\n actions.push(act({ type: 'type', text }))\n if (pressEnter) {\n actions.push(act({ type: 'keypress', keys: ['Return'] }))\n }\n return actions\n }\n\n case 'key_combination': {\n const rawKeys = args.keys\n let keys: string[]\n if (Array.isArray(rawKeys)) {\n keys = rawKeys.map(String).map(normalizeGeminiKey)\n } else if (typeof rawKeys === 'string') {\n keys = rawKeys.split(/[+\\s]+/).map(k => k.trim()).filter(Boolean).map(normalizeGeminiKey)\n } else {\n keys = []\n }\n return [act({ type: 'keypress', keys })]\n }\n\n case 'scroll_at': {\n const direction = typeof args.direction === 'string' ? args.direction : undefined\n const amount = typeof args.amount === 'number' ? args.amount : 3\n const { scroll_x, scroll_y } = scrollFromDirection(direction, amount)\n return [act({ type: 'scroll', x, y, scroll_x, scroll_y })]\n }\n\n case 'scroll_document': {\n const direction = typeof args.direction === 'string' ? args.direction : undefined\n const amount = typeof args.amount === 'number' ? args.amount : 3\n const { scroll_x, scroll_y } = scrollFromDirection(direction, amount)\n return [act({ type: 'scroll', x: 640, y: 360, scroll_x, scroll_y })]\n }\n\n case 'drag_and_drop': {\n const destX = typeof args.destination_x === 'number' ? args.destination_x : 0\n const destY = typeof args.destination_y === 'number' ? args.destination_y : 0\n return [act({ type: 'drag', path: [{ x, y }, { x: destX, y: destY }] })]\n }\n\n case 'wait_5_seconds':\n case 'wait_for_load':\n return [act({ type: 'wait' })]\n\n // navigate, go_back, go_forward, open_web_browser, search are excluded\n // via excludedPredefinedFunctions in the tool config\n\n default:\n return [act({ type: name, ...args })]\n }\n}\n","import type { GoogleGenAI } from '@google/genai'\nimport { post } from './post'\n\nexport const completions = ({\n google,\n}: {\n google: GoogleGenAI\n}) => ({\n post: post({ google }),\n})\n","import type { GoogleGenAI } from '@google/genai'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const googleClientAdapter = ({\n google,\n}: {\n google: GoogleGenAI\n}) => ({\n client: google,\n requestHandlers: {\n '^/v1/models$': models({ google }),\n '^/(?:v1\|/?openai)/chat/completions$': completions({ google }),\n },\n})\n","import type OpenAI from 'openai'\n\nconst models = [\n 'Humiris/humiris-moai',\n]\n\nexport const get = ({\n humiris,\n}: {\n humiris: OpenAI\n}) => async (_url: string, _options: any) => {\n try {\n return new Response(JSON.stringify({\n type: 'list',\n data: models.map((model) => ({\n id: model,\n object: 'model',\n })),\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type OpenAI from 'openai'\nimport { get } from './get'\n\nexport const models = ({\n humiris,\n}: {\n humiris: OpenAI\n}) => ({\n get: get({ humiris }),\n})\n","import type OpenAI from 'openai'\n\nexport const post = ({\n humiris,\n}: {\n humiris: OpenAI\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n\n if (body.stream) {\n const data = await humiris.chat.completions.create({\n ...body,\n stream: false,\n })\n\n const stream = new ReadableStream({\n async start(controller) {\n const chunk = {\n id: data.id,\n object: 'chat.completion.chunk',\n created: data.created,\n model: data.created,\n choices: [\n {\n index: 0,\n delta: {\n role: data.choices[0].message.role,\n content: data.choices[0].message.content,\n },\n logprobs: null,\n finish_reason: data.choices[0].finish_reason,\n }\n ]\n }\n\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await humiris.chat.completions.create(body)\n\n return new Response(JSON.stringify({\n data,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","import type OpenAI from 'openai'\nimport { post } from './post'\n\nexport const completions = ({\n humiris,\n}: {\n humiris: OpenAI\n}) => ({\n post: post({ humiris }),\n})\n","import type OpenAI from 'openai'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const humirisClientAdapter = ({\n humiris,\n}: {\n humiris: OpenAI\n}) => ({\n client: humiris,\n requestHandlers: {\n '^/v1/models$': models({ humiris }),\n '^/(?:v1\|/?openai)/chat/completions$': completions({ humiris }),\n },\n})\n","import type OpenAI from 'openai'\n\nexport const get = ({\n ollama,\n}: {\n ollama: OpenAI\n}) => async (_url: string, _options: any) => {\n try {\n const data = await ollama.models.list()\n\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type OpenAI from 'openai'\nimport { get } from './get'\n\nexport const models = ({\n ollama,\n}: {\n ollama: OpenAI\n}) => ({\n get: get({ ollama }),\n})\n","import type OpenAI from 'openai'\n\nexport const post = ({\n ollama,\n}: {\n ollama: OpenAI\n}) => async (_url: string, options: any) => {\n const body = JSON.parse(options.body)\n\n if (body.stream) {\n const response = await ollama.chat.completions.create(body)\n\n const stream = new ReadableStream({\n async start(controller) {\n // @ts-ignore-next-line\n for await (const chunk of response) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n return new Response(stream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n try {\n const data = await ollama.chat.completions.create(body)\n\n return new Response(JSON.stringify({\n data,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n}\n","import type OpenAI from 'openai'\nimport { post } from './post'\n\nexport const completions = ({\n ollama,\n}: {\n ollama: OpenAI\n}) => ({\n post: post({ ollama }),\n})\n","import type OpenAI from 'openai'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const ollamaClientAdapter = ({\n ollama,\n}: {\n ollama: OpenAI\n}) => ({\n client: ollama,\n requestHandlers: {\n '^/v1/models$': models({ ollama }),\n '^/(?:v1\|/?openai)/chat/completions$': completions({ ollama }),\n },\n})\n","import type { OpenRouter } from '@openrouter/sdk'\n\nexport const get = ({\n openRouter,\n}: {\n openRouter: OpenRouter\n}) => async (_url: string, _options: any) => {\n try {\n const data = await openRouter.models.list()\n\n const openaiModels = {\n object: 'list',\n data: data.data.map((m: any) => ({\n id: m.id,\n object: 'model',\n created: m.created,\n owned_by: m.id.split('/')[0] \|\| 'openrouter',\n })),\n }\n\n return new Response(JSON.stringify(openaiModels), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n } catch (error) {\n return new Response(JSON.stringify({\n error,\n }), {\n status: 500,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type { OpenRouter } from '@openrouter/sdk'\nimport { get } from './get'\n\nexport const models = ({\n openRouter,\n}: {\n openRouter: OpenRouter\n}) => ({\n get: get({ openRouter }),\n})\n","// Per-model quirks. Only models listed here get special treatment.\nconst MODEL_QUIRKS: Record<string, {\n // Coordinates are 0-1000 normalized (not pixels)\n normalizedCoords?: boolean\n // Coordinates are 0.0-1.0 relative OR in a reference resolution (e.g. 1920x1080)\n relativeCoords?: { referenceWidth: number; referenceHeight: number }\n // Model injects native tool format tags (<arg_key>, <arg_value>, <\|begin_of_box\|>)\n cleanArtifacts?: boolean\n // Model sometimes produces malformed JSON that needs fuzzy extraction\n fuzzyFallback?: boolean\n}> = {\n 'z-ai/glm-4.6v': { normalizedCoords: true, cleanArtifacts: true },\n 'qwen/': { fuzzyFallback: true },\n 'moonshotai/kimi-k2.5': { relativeCoords: { referenceWidth: 1920, referenceHeight: 1080 } },\n}\n\nexport const getQuirks = (model: string) => {\n for (const [prefix, quirks] of Object.entries(MODEL_QUIRKS)) {\n if (model.startsWith(prefix)) return quirks\n }\n return {}\n}\n\n// --- GLM artifact cleanup (only applied when cleanArtifacts is true) ---\n\nconst cleanTextArtifacts = (text: string): string =>\n text\n .replace(/<\\\|begin_of_box\\\|>/g, '')\n .replace(/<\\\|end_of_box\\\|>/g, '')\n .replace(/<arg_key>[^<]<\\/arg_key>/g, '')\n .replace(/<\\/arg_value>/g, '')\n .trim()\n\n// GLM embeds its native tool format in the type field, e.g.:\n// { type: \"click\\n<arg_key>parameters</arg_key>\\n<arg_value>{\\\"type\\\":\\\"click\\\",\\\"x\\\":167,\\\"y\\\":622}\" }\n// Sorted by length desc so \"double_click\" is checked before \"click\"\nconst KNOWN_ACTION_TYPES = ['double_click', 'screenshot', 'keypress', 'scroll', 'click', 'move', 'type', 'drag', 'wait']\n\n// Try to split a digit string into two valid 0-1000 coordinates\nconst splitCoordDigits = (numStr: string): { x: number; y: number } \| null => {\n for (let i = 1; i < numStr.length; i++) {\n const x = parseInt(numStr.slice(0, i))\n const y = parseInt(numStr.slice(i))\n if (x >= 0 && x <= 1000 && y >= 0 && y <= 1000) {\n return { x, y }\n }\n }\n return null\n}\n\nconst cleanGlmAction = (action: Record<string, unknown>): Record<string, unknown> => {\n const typeVal = action.type\n if (typeof typeVal !== 'string') return action\n\n // Try extracting JSON from embedded <arg_value>{...} in the type field\n const argValueMatch = typeVal.match(/<arg_value>\\s(\\{[\\s\\S]\\})\\s$/)\n if (argValueMatch) {\n const inner = parseJson(argValueMatch[1])\n if (inner && typeof inner === 'object') {\n return inner\n }\n }\n\n // Strip all tags and whitespace\n const cleanedType = typeVal\n .replace(/<\\/?[^>]+>/g, '')\n .replace(/\\n/g, '')\n .trim()\n\n // Check if type starts with a known action type followed by garbage\n // Handles: \"clickclick167622\" → click + 167, 622\n // \"click167621\" → click + 167, 621\n for (const actionType of KNOWN_ACTION_TYPES) {\n if (cleanedType.startsWith(actionType) && cleanedType !== actionType) {\n const rest = cleanedType.slice(actionType.length)\n const nums = rest.match(/\\d+/g)\n if (nums && nums.length >= 2) {\n return { ...action, type: actionType, x: parseInt(nums[0]), y: parseInt(nums[1]) }\n }\n // Single concatenated number: try to split into valid 0-1000 coordinate pair\n if (nums && nums.length === 1 && nums[0].length >= 2) {\n const coords = splitCoordDigits(nums[0])\n if (coords) {\n return { ...action, type: actionType, ...coords }\n }\n }\n // No coordinates, just duplicated/garbled type name\n return { ...action, type: actionType }\n }\n }\n\n if (cleanedType === typeVal) return action\n\n return { ...action, type: cleanedType }\n}\n\n// E.g. x: \"167</arg_key>\\n\\n<arg_value>620\" → extract x=167, y=620\nconst cleanGlmFields = (action: Record<string, unknown>): Record<string, unknown> => {\n const result = { ...action }\n\n if (typeof result.x === 'string') {\n const nums = (result.x as string).match(/\\d+/g)\n if (nums && nums.length >= 2) {\n result.x = parseInt(nums[0])\n if (result.y === undefined \|\| typeof result.y === 'string') {\n result.y = parseInt(nums[1])\n }\n } else if (nums && nums.length === 1) {\n result.x = parseInt(nums[0])\n }\n }\n\n if (typeof result.y === 'string') {\n const nums = (result.y as string).match(/\\d+/g)\n if (nums && nums.length >= 1) {\n result.y = parseInt(nums[0])\n }\n }\n\n for (const key of ['scroll_x', 'scroll_y'] as const) {\n if (typeof result[key] === 'string') {\n const nums = (result[key] as string).match(/\\d+/g)\n if (nums) result[key] = parseInt(nums[0])\n }\n }\n\n if (typeof result.type === 'string') {\n result.type = (result.type as string)\n .replace(/<[^>]>/g, '')\n .replace(/^\\{\|\\}$/g, '')\n .replace(/\\n/g, '')\n .trim()\n }\n\n return result\n}\n\nconst applyArtifactCleanup = (action: Record<string, unknown>): Record<string, unknown> =>\n cleanGlmFields(cleanGlmAction(action))\n\n// --- Generic helpers ---\n\nconst parseJson = (text: string): any => {\n try {\n return JSON.parse(text)\n } catch {\n return undefined\n }\n}\n\nconst extractJson = (text: string): any => {\n const direct = parseJson(text)\n if (direct) return direct\n\n const codeBlockMatch = text.match(/```(?:json)?\\s([\\s\\S]?)```/)\n if (codeBlockMatch) {\n const parsed = parseJson(codeBlockMatch[1].trim())\n if (parsed) return parsed\n }\n\n const jsonMatch = text.match(/(\\{[\\s\\S]\\})\\s$/)\n if (jsonMatch) {\n const parsed = parseJson(jsonMatch[1].trim())\n if (parsed) return parsed\n }\n\n return undefined\n}\n\n// Fuzzy extraction for severely malformed output\nconst fuzzyExtractJson = (text: string): any => {\n const clickMatch = text.match(/\"action\"\\s:\\s\"click\"\\s,\\s\"x\"\\s:\\s\\[?\\s(\\d+)\\s,\\s(\\d+)/)\n if (clickMatch) {\n return { action: { type: 'click', x: parseInt(clickMatch[1]), y: parseInt(clickMatch[2]) } }\n }\n\n const actionTypeMatch = text.match(/\"type\"\\s:\\s\"(\\w+)\"/)\n if (actionTypeMatch) {\n const result: Record<string, unknown> = { type: actionTypeMatch[1] }\n const xMatch = text.match(/\"x\"\\s:\\s\\[?\\s(\\d+)/)\n const yMatch = text.match(/\"y\"\\s:\\s(\\d+)/)\n if (xMatch) result.x = parseInt(xMatch[1])\n if (yMatch) {\n result.y = parseInt(yMatch[1])\n } else if (xMatch) {\n // Handle malformed array-like coords: \"x\": 168, 621] or \"x\": [168, 621]\n const afterX = text.slice((xMatch.index ?? 0) + xMatch[0].length)\n const nextNum = afterX.match(/\\s,?\\s(\\d+)/)\n if (nextNum) result.y = parseInt(nextNum[1])\n }\n const textMatch = text.match(/\"text\"\\s:\\s\"([^\"])\"/)\n if (textMatch) result.text = textMatch[1]\n return { action: result }\n }\n\n return undefined\n}\n\nconst denormalize = (\n value: number,\n dimension: number,\n): number => Math.round((value / 1000) dimension)\n\nconst denormalizeAction = (\n action: Record<string, unknown>,\n displayWidth: number,\n displayHeight: number,\n): Record<string, unknown> => {\n const result = { ...action }\n\n if (typeof result.x === 'number') {\n result.x = denormalize(result.x as number, displayWidth)\n }\n if (typeof result.y === 'number') {\n result.y = denormalize(result.y as number, displayHeight)\n }\n\n if (Array.isArray(result.path)) {\n result.path = (result.path as any[]).map((point) => {\n if (point && typeof point === 'object') {\n return {\n ...point,\n ...(typeof point.x === 'number' ? { x: denormalize(point.x, displayWidth) } : {}),\n ...(typeof point.y === 'number' ? { y: denormalize(point.y, displayHeight) } : {}),\n }\n }\n return point\n })\n }\n\n return result\n}\n\n// --- Relative / reference-resolution coordinate rescaling (Kimi K2.5) ---\n\nconst rescaleCoord = (\n value: number,\n displayDim: number,\n referenceDim: number,\n): number => {\n // ≤ 1.0 → relative (0.0-1.0), multiply by display dimension\n if (value <= 1.0) return Math.round(value * displayDim)\n // > 1.0 → reference resolution pixels, rescale to display dimension\n return Math.round((value / referenceDim) * displayDim)\n}\n\nconst rescaleRelativeAction = (\n action: Record<string, unknown>,\n displayWidth: number,\n displayHeight: number,\n referenceWidth: number,\n referenceHeight: number,\n): Record<string, unknown> => {\n const result = { ...action }\n\n if (typeof result.x === 'number') {\n result.x = rescaleCoord(result.x as number, displayWidth, referenceWidth)\n }\n if (typeof result.y === 'number') {\n result.y = rescaleCoord(result.y as number, displayHeight, referenceHeight)\n }\n\n if (Array.isArray(result.path)) {\n result.path = (result.path as any[]).map((point) => {\n if (point && typeof point === 'object') {\n return {\n ...point,\n ...(typeof point.x === 'number' ? { x: rescaleCoord(point.x, displayWidth, referenceWidth) } : {}),\n ...(typeof point.y === 'number' ? { y: rescaleCoord(point.y, displayHeight, referenceHeight) } : {}),\n }\n }\n return point\n })\n }\n\n return result\n}\n\n// --- Structure normalization (universal — any model might produce flat format) ---\n\nconst COORD_FIELDS = ['x', 'y', 'text', 'keys', 'button', 'direction', 'scroll_x', 'scroll_y', 'path']\n\nconst normalizeStructure = (\n parsed: Record<string, unknown>,\n shouldCleanArtifacts: boolean,\n): Record<string, unknown> => {\n const clean = shouldCleanArtifacts\n ? (action: Record<string, unknown>) => applyArtifactCleanup(action)\n : (action: Record<string, unknown>) => action\n\n // Already nested: { action: { type: 'click', ... } }\n if (parsed.action && typeof parsed.action === 'object') {\n return { ...parsed, action: clean(parsed.action as Record<string, unknown>) }\n }\n\n // Flat with string action: { action: 'click', x: 168, y: 622 }\n if (typeof parsed.action === 'string') {\n const actionObj: Record<string, unknown> = { type: parsed.action }\n const rest: Record<string, unknown> = {}\n for (const [key, value] of Object.entries(parsed)) {\n if (key === 'action') continue\n if (COORD_FIELDS.includes(key)) {\n actionObj[key] = value\n } else {\n rest[key] = value\n }\n }\n return { ...rest, action: clean(actionObj) }\n }\n\n // Flat without action key: { type: 'click', x: 168, y: 622 }\n if (typeof parsed.type === 'string') {\n const actionObj: Record<string, unknown> = {}\n const rest: Record<string, unknown> = {}\n for (const [key, value] of Object.entries(parsed)) {\n if (key === 'type' \|\| COORD_FIELDS.includes(key)) {\n actionObj[key] = value\n } else {\n rest[key] = value\n }\n }\n return { ...rest, action: clean(actionObj) }\n }\n\n return parsed\n}\n\n// --- Main entry point ---\n\nexport const denormalizeComputerCallArguments = ({\n argumentsText,\n displayWidth,\n displayHeight,\n model,\n}: {\n argumentsText: string\n displayWidth: number\n displayHeight: number\n model: string\n}): string => {\n // Handle case where arguments are already a parsed object (some models via OpenRouter)\n if (typeof argumentsText === 'object' && argumentsText !== null) {\n argumentsText = JSON.stringify(argumentsText)\n }\n\n const quirks = getQuirks(model)\n\n // Step 1: Parse JSON (with artifact cleanup only for known models)\n let text = argumentsText\n if (quirks.cleanArtifacts) {\n text = cleanTextArtifacts(text)\n }\n\n let parsed = extractJson(text)\n if (!parsed && (quirks.cleanArtifacts \|\| quirks.fuzzyFallback)) {\n parsed = fuzzyExtractJson(text)\n }\n\n if (!parsed \|\| typeof parsed !== 'object') {\n return argumentsText\n }\n\n // Step 2: Normalize structure (universal) + artifact cleanup (model-specific)\n const normalized = normalizeStructure(parsed, !!quirks.cleanArtifacts)\n\n // Step 3: Denormalize coordinates (model-specific)\n if (quirks.normalizedCoords && normalized.action && typeof normalized.action === 'object') {\n return JSON.stringify({\n ...normalized,\n action: denormalizeAction(\n normalized.action as Record<string, unknown>,\n displayWidth,\n displayHeight,\n ),\n })\n }\n\n if (quirks.relativeCoords && normalized.action && typeof normalized.action === 'object') {\n return JSON.stringify({\n ...normalized,\n action: rescaleRelativeAction(\n normalized.action as Record<string, unknown>,\n displayWidth,\n displayHeight,\n quirks.relativeCoords.referenceWidth,\n quirks.relativeCoords.referenceHeight,\n ),\n })\n }\n\n return JSON.stringify(normalized)\n}\n","import type OpenAI from 'openai'\nimport { getQuirks } from './normalizeComputerCall'\n\n// Matches OpenAI's computer_call output format: { action: { type, x, y, ... }, pending_safety_checks: [] }\nconst buildComputerCallFunction = (model: string, displayWidth: number, displayHeight: number): OpenAI.FunctionDefinition => {\n const quirks = getQuirks(model)\n\n const coordDesc = quirks.normalizedCoords\n ? 'Coordinates use 0-1000 normalized scale (0,0=top-left, 1000,1000=bottom-right).'\n : quirks.relativeCoords\n ? `Coordinates are relative (0.0-1.0) where 0.0,0.0 is top-left and 1.0,1.0 is bottom-right. Screen is ${displayWidth}x${displayHeight}.`\n : `Coordinates are in pixels (screen is ${displayWidth}x${displayHeight}).`\n\n const xDesc = quirks.normalizedCoords\n ? 'X coordinate (0-1000 normalized)'\n : quirks.relativeCoords\n ? 'X coordinate (0.0-1.0 relative, where 0.0=left edge, 1.0=right edge)'\n : `X coordinate in pixels (0-${displayWidth})`\n\n const yDesc = quirks.normalizedCoords\n ? 'Y coordinate (0-1000 normalized)'\n : quirks.relativeCoords\n ? 'Y coordinate (0.0-1.0 relative, where 0.0=top edge, 1.0=bottom edge)'\n : `Y coordinate in pixels (0-${displayHeight})`\n\n return {\n name: 'computer_call',\n description: `Perform a computer action. ${coordDesc}`,\n parameters: {\n type: 'object',\n properties: {\n action: {\n type: 'object',\n description: 'The action to perform',\n properties: {\n type: {\n type: 'string',\n enum: [\n 'screenshot',\n 'click',\n 'double_click',\n 'type',\n 'keypress',\n 'scroll',\n 'move',\n 'drag',\n 'wait',\n ],\n },\n x: { type: 'number', description: xDesc },\n y: { type: 'number', description: yDesc },\n text: { type: 'string', description: 'Text to type' },\n keys: {\n type: 'array',\n items: { type: 'string' },\n description: 'Keys to press',\n },\n button: {\n type: 'string',\n enum: ['left', 'right', 'wheel'],\n },\n direction: {\n type: 'string',\n enum: ['up', 'down', 'left', 'right'],\n },\n scroll_x: { type: 'number' },\n scroll_y: { type: 'number' },\n path: {\n type: 'array',\n items: {\n type: 'object',\n properties: {\n x: { type: 'number' },\n y: { type: 'number' },\n },\n },\n description: 'Path for drag action',\n },\n },\n required: ['type'],\n },\n pending_safety_checks: {\n type: 'array',\n items: { type: 'object' },\n },\n },\n required: ['action'],\n },\n }\n}\n\nexport type ComputerUseConfig = {\n displayWidth: number\n displayHeight: number\n}\n\nexport const transformTools = (\n tools: any[] \| undefined,\n model: string,\n): { tools: any[]; computerUseConfig: ComputerUseConfig \| null } => {\n if (!tools \|\| tools.length === 0) {\n return { tools: tools ?? [], computerUseConfig: null }\n }\n\n let computerUseConfig: ComputerUseConfig \| null = null\n\n const transformed = tools.map((tool) => {\n if (tool.type === 'computer_use_preview') {\n const config = tool.computer_use_preview ?? tool\n computerUseConfig = {\n displayWidth: config.display_width ?? config.display_width_px ?? 1280,\n displayHeight: config.display_height ?? config.display_height_px ?? 720,\n }\n return {\n type: 'function' as const,\n function: buildComputerCallFunction(model, computerUseConfig.displayWidth, computerUseConfig.displayHeight),\n }\n }\n return tool\n })\n\n return { tools: transformed, computerUseConfig }\n}\n","import type { OpenRouter } from '@openrouter/sdk'\nimport { transformTools } from './computerUseTool'\nimport { denormalizeComputerCallArguments, getQuirks } from './normalizeComputerCall'\n\nconst ARTIFACT_TAGS = /<\\\|begin_of_box\\\|>\|<\\\|end_of_box\\\|>/g\n\nconst sanitizeContent = (content: string \| null \| undefined): string \| null \| undefined => {\n if (!content) return content\n return content.replace(ARTIFACT_TAGS, '').trim()\n}\n\n// Convert computer_screenshot JSON in tool messages to image_url content\n// so the model can see screenshot images. This is OpenRouter-specific because\n// each provider handles image content in tool messages differently.\nconst convertScreenshotToolMessages = (messages: Record<string, unknown>[]): Record<string, unknown>[] =>\n messages.map((msg) => {\n if (msg.role !== 'tool' \|\| typeof msg.content !== 'string') return msg\n\n try {\n const parsed = JSON.parse(msg.content)\n if (parsed.type === 'computer_screenshot' && parsed.image_url) {\n return {\n ...msg,\n content: [\n { type: 'image_url', image_url: { url: parsed.image_url } },\n ],\n }\n }\n } catch {}\n\n return msg\n })\n\nconst resolveApiKey = async (\n apiKey: string \| (() => Promise<string>) \| undefined,\n): Promise<string> => {\n if (!apiKey) return ''\n return typeof apiKey === 'function' ? await apiKey() : apiKey\n}\n\n// Parse SSE stream from a raw Response, yielding each parsed JSON chunk.\n// Bypasses the SDK's strict Zod validation that rejects null tool_call IDs\n// in streaming delta chunks (a valid OpenAI streaming convention).\nasync function* parseSSE(response: Response): AsyncGenerator<Record<string, unknown>> {\n const reader = response.body!.getReader()\n const decoder = new TextDecoder()\n let buffer = ''\n\n try {\n while (true) {\n const { done, value } = await reader.read()\n if (done) break\n buffer += decoder.decode(value, { stream: true })\n\n const lines = buffer.split('\\n')\n buffer = lines.pop() ?? ''\n\n for (const line of lines) {\n const trimmed = line.trim()\n if (!trimmed.startsWith('data: ')) continue\n const data = trimmed.slice(6)\n if (data === '[DONE]') return\n try {\n yield JSON.parse(data)\n } catch {}\n }\n }\n } finally {\n reader.releaseLock()\n }\n}\n\n// Make a raw request to the OpenRouter API, bypassing the SDK's response\n// Zod validation (which rejects null tool_call IDs in streaming deltas).\n// The API accepts and returns OpenAI-compatible format directly.\nconst rawFetch = async (\n openRouter: OpenRouter,\n body: Record<string, unknown>,\n): Promise<Response> => {\n const apiKey = await resolveApiKey(openRouter._options.apiKey)\n const baseURL = (openRouter._baseURL?.toString() ?? 'https://openrouter.ai/api/v1').replace(/\\/+$/, '')\n\n const headers: Record<string, string> = {\n 'Content-Type': 'application/json',\n 'Authorization': `Bearer ${apiKey}`,\n }\n if (body.stream) {\n headers['Accept'] = 'text/event-stream'\n }\n if (openRouter._options.httpReferer) {\n headers['HTTP-Referer'] = openRouter._options.httpReferer\n }\n if (openRouter._options.xTitle) {\n headers['X-Title'] = openRouter._options.xTitle\n }\n\n const request = new Request(`${baseURL}/chat/completions`, {\n method: 'POST',\n headers,\n body: JSON.stringify(body),\n })\n\n // Use the SDK's HTTPClient if available (preserves custom fetcher config\n // like Connection: close), otherwise fall back to global fetch\n const httpClient = openRouter._options.httpClient\n return httpClient\n ? httpClient.request(request)\n : fetch(request)\n}\n\nexport const post = ({\n openRouter,\n provider,\n}: {\n openRouter: OpenRouter\n provider?: Record<string, unknown>\n}) => async (_url: string, options: { body: string }) => {\n const body = JSON.parse(options.body)\n const model = body.model as string\n\n const { tools: transformedTools, computerUseConfig } = transformTools(body.tools, model)\n\n const resultOptions = {\n ...body,\n ...(provider && !body.provider ? { provider } : {}),\n ...(computerUseConfig && body.messages ? { messages: convertScreenshotToolMessages(body.messages) } : {}),\n ...(transformedTools.length > 0 ? { tools: transformedTools } : {}),\n }\n\n if (body.stream) {\n const response = await rawFetch(openRouter, resultOptions)\n\n if (!response.ok) {\n return new Response(response.body, {\n status: response.status,\n headers: { 'Content-Type': response.headers.get('Content-Type') ?? 'application/json' },\n })\n }\n\n const shouldCleanArtifacts = getQuirks(model).cleanArtifacts\n\n if (!computerUseConfig && !shouldCleanArtifacts) {\n // Pass through the raw SSE response directly — no need to parse and\n // re-serialize when we don't need to modify the chunks.\n return new Response(response.body, {\n status: response.status,\n headers: { 'Content-Type': 'text/event-stream' },\n })\n }\n\n if (!computerUseConfig) {\n const readableStream = new ReadableStream({\n async start(controller) {\n for await (const chunk of parseSSE(response)) {\n const delta = (chunk.choices as Record<string, unknown>[] \| undefined)?.[0] as Record<string, unknown> \| undefined\n const d = delta?.delta as Record<string, unknown> \| undefined\n if (d?.content && typeof d.content === 'string') {\n d.content = sanitizeContent(d.content)\n }\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n }\n controller.close()\n },\n })\n\n return new Response(readableStream, {\n headers: { 'Content-Type': 'text/event-stream' },\n })\n }\n\n const { displayWidth, displayHeight } = computerUseConfig\n\n const readableStream = new ReadableStream({\n async start(controller) {\n const computerCallIndices = new Set<number>()\n const argumentBuffers = new Map<number, string>()\n const emittedIndices = new Set<number>()\n\n for await (const chunk of parseSSE(response)) {\n const choices = (chunk.choices ?? []) as Record<string, unknown>[]\n const choice = choices[0] as Record<string, unknown> \| undefined\n\n const delta = choice?.delta as Record<string, unknown> \| undefined\n const toolCalls = delta?.tool_calls as Record<string, unknown>[] \| undefined\n\n if (!toolCalls) {\n controller.enqueue(`data: ${JSON.stringify(chunk)}\\n\\n`)\n continue\n }\n\n const passThrough: Record<string, unknown>[] = []\n\n for (const tc of toolCalls) {\n const fn = tc.function as Record<string, unknown> \| undefined\n\n if (fn?.name === 'computer_call') {\n computerCallIndices.add(tc.index as number)\n const initialArgs = (fn?.arguments ?? '') as string\n argumentBuffers.set(tc.index as number, initialArgs)\n\n if (initialArgs) {\n try {\n JSON.parse(initialArgs)\n const denormalized = denormalizeComputerCallArguments({\n argumentsText: initialArgs,\n displayWidth,\n displayHeight,\n model,\n })\n passThrough.push({\n ...tc,\n function: { ...fn, arguments: denormalized },\n })\n emittedIndices.add(tc.index as number)\n continue\n } catch {\n // Not complete JSON yet — will be handled in subsequent chunks\n }\n }\n\n passThrough.push({\n ...tc,\n function: { ...fn, arguments: '' },\n })\n continue\n }\n\n if (computerCallIndices.has(tc.index as number)) {\n const buf = (argumentBuffers.get(tc.index as number) ?? '') + ((fn?.arguments ?? '') as string)\n argumentBuffers.set(tc.index as number, buf)\n\n if (!emittedIndices.has(tc.index as number)) {\n try {\n JSON.parse(buf)\n const denormalized = denormalizeComputerCallArguments({\n argumentsText: buf,\n displayWidth,\n displayHeight,\n model,\n })\n passThrough.push({\n index: tc.index,\n function: { arguments: denormalized },\n })\n emittedIndices.add(tc.index as number)\n } catch {\n // Not complete JSON yet — keep buffering\n }\n }\n continue\n }\n\n passThrough.push(tc)\n }\n\n if (passThrough.length > 0) {\n const modifiedChunk = {\n ...chunk,\n choices: [{\n ...choice,\n delta: {\n ...delta,\n tool_calls: passThrough,\n },\n }],\n }\n controller.enqueue(`data: ${JSON.stringify(modifiedChunk)}\\n\\n`)\n }\n }\n\n // Flush any remaining buffered computer_call arguments\n for (const [index, buf] of Array.from(argumentBuffers)) {\n if (!emittedIndices.has(index) && buf) {\n const denormalized = denormalizeComputerCallArguments({\n argumentsText: buf,\n displayWidth,\n displayHeight,\n model,\n })\n const flushChunk = {\n object: 'chat.completion.chunk',\n choices: [{\n index: 0,\n delta: {\n tool_calls: [{\n index,\n function: { arguments: denormalized },\n }],\n },\n }],\n }\n controller.enqueue(`data: ${JSON.stringify(flushChunk)}\\n\\n`)\n }\n }\n\n controller.close()\n },\n })\n\n return new Response(readableStream, {\n headers: { 'Content-Type': 'text/event-stream' },\n })\n } else {\n try {\n const response = await rawFetch(openRouter, resultOptions)\n\n if (!response.ok) {\n return new Response(response.body, {\n status: response.status,\n headers: { 'Content-Type': response.headers.get('Content-Type') ?? 'application/json' },\n })\n }\n\n const data = await response.json()\n\n if (computerUseConfig) {\n for (const choice of (data.choices ?? []) as Record<string, unknown>[]) {\n const message = choice.message as Record<string, unknown> \| undefined\n const toolCalls = (message?.tool_calls ?? []) as Record<string, unknown>[]\n for (const tc of toolCalls) {\n const fn = tc.function as Record<string, unknown> \| undefined\n if (fn?.name === 'computer_call') {\n fn.arguments = denormalizeComputerCallArguments({\n argumentsText: fn.arguments as string,\n displayWidth: computerUseConfig.displayWidth,\n displayHeight: computerUseConfig.displayHeight,\n model,\n })\n }\n }\n }\n }\n\n if (getQuirks(model).cleanArtifacts) {\n for (const choice of (data.choices ?? []) as Record<string, unknown>[]) {\n const message = choice.message as Record<string, unknown> \| undefined\n if (message?.content && typeof message.content === 'string') {\n message.content = sanitizeContent(message.content)!\n }\n }\n }\n\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: { 'Content-Type': 'application/json' },\n })\n } catch (error) {\n return new Response(JSON.stringify({ error }), {\n status: 500,\n headers: { 'Content-Type': 'application/json' },\n })\n }\n }\n}\n","import type { OpenRouter } from '@openrouter/sdk'\nimport { post } from './post'\n\nexport const completions = ({\n openRouter,\n provider,\n}: {\n openRouter: OpenRouter\n provider?: Record<string, unknown>\n}) => ({\n post: post({ openRouter, provider }),\n})\n","import type { OpenRouter } from '@openrouter/sdk'\nimport { models } from './models'\nimport { completions } from './completions'\n\nexport const openRouterClientAdapter = ({\n openRouter,\n provider,\n}: {\n openRouter: OpenRouter\n provider?: Record<string, unknown>\n}) => ({\n client: openRouter,\n requestHandlers: {\n '^/v1/models$': models({ openRouter }),\n '^/(?:v1\|/?openai)/chat/completions$': completions({ openRouter, provider }),\n },\n})\n","import _ from 'lodash'\nimport { uid, omit, isEmpty } from 'radash'\nimport dayjs from 'dayjs'\nimport OpenAI from 'openai'\nimport { MessageWithRun } from '@/types'\nimport { messages } from './messages'\n\nconst updatedToolCall = ({\n toolCall,\n delta,\n}: {\n toolCall: any\n delta: any\n}) => {\n if (!toolCall) return omit(delta, ['index'])\n\n // if (delta.type !== 'function') return toolCall\n\n const result = _.cloneDeep(toolCall)\n\n for (const [key, value] of Object.entries(delta.function)) {\n result.function[key] = `${result.function[key] ?? ''}${value}`\n }\n\n return result\n}\n\nconst toolCallsData = ({\n prevToolCalls,\n delta,\n}: {\n prevToolCalls: any\n delta: any\n}) => {\n if (!prevToolCalls) {\n return delta.tool_calls.map((tc: any) => ({\n id: uid(24),\n type: tc.type ?? 'function',\n ...omit(tc, ['index']),\n }))\n }\n\n const newToolCalls = _.cloneDeep(prevToolCalls)\n\n for (const runStepDelta of delta.tool_calls) {\n newToolCalls[runStepDelta.index] = updatedToolCall({\n toolCall: newToolCalls[runStepDelta.index],\n delta: runStepDelta,\n })\n }\n\n return newToolCalls\n}\n\nexport const completionsRunAdapter = () => {\n return {\n handleRun: async ({\n client,\n run,\n onEvent,\n getMessages,\n }: {\n client: OpenAI\n run: OpenAI.Beta.Threads.Run\n onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<any>\n getMessages: () => Promise<MessageWithRun[]>\n }) => {\n if (run.status !== 'queued') return\n\n onEvent({\n event: 'thread.run.in_progress',\n data: {\n ...run,\n status: 'in_progress',\n },\n })\n\n const opts = {\n messages: await messages({\n run,\n getMessages,\n }),\n model: run.model,\n stream: true,\n response_format: run.response_format,\n ...(isEmpty(run.tools) ? {} : { tools: run.tools }),\n } as OpenAI.ChatCompletionCreateParamsStreaming\n\n let providerResponse\n\n try {\n providerResponse = await client.chat.completions.create(opts)\n } catch(e: any) {\n console.error(e)\n\n return onEvent({\n event: 'thread.run.failed',\n data: {\n ...run,\n failed_at: dayjs().unix(),\n status: 'in_progress',\n last_error: {\n code: 'server_error',\n message: `${e?.message ?? ''} ${e?.cause?.message ?? ''}`,\n },\n },\n })\n }\n\n let message = await onEvent({\n event: 'thread.message.created',\n data: {\n id: 'THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID',\n object: 'thread.message',\n completed_at: null,\n run_id: run.id,\n created_at: dayjs().unix(),\n assistant_id: run.assistant_id,\n incomplete_at: null,\n incomplete_details: null,\n metadata: {},\n attachments: [],\n thread_id: run.thread_id,\n content: [{ text: { value: '', annotations: [] }, type: 'text' }],\n role: 'assistant',\n status: 'in_progress',\n },\n })\n\n onEvent({\n event: 'thread.run.step.created',\n data: {\n id: 'THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID',\n object: 'thread.run.step',\n run_id: run.id,\n assistant_id: run.assistant_id,\n thread_id: run.thread_id,\n type: 'message_creation',\n status: 'completed',\n completed_at: dayjs().unix(),\n created_at: dayjs().unix(),\n expired_at: null,\n last_error: null,\n metadata: {},\n failed_at: null,\n cancelled_at: null,\n usage: null,\n step_details: {\n type: 'message_creation',\n message_creation: {\n message_id: message.id,\n },\n },\n },\n })\n\n let toolCallsRunStep\n let currentContent = ''\n let currentToolCalls\n\n for await (const chunk of providerResponse) {\n const choices = chunk.choices ?? []\n const choice = choices[0]\n if (!choice) continue\n\n const delta = choice.delta\n\n if (delta.content) {\n currentContent = `${currentContent}${delta.content ?? ''}`\n }\n\n if (delta.tool_calls) {\n if (!toolCallsRunStep) {\n toolCallsRunStep = await onEvent({\n event: 'thread.run.step.created',\n data: {\n id: 'THERE_IS_A_BUG_IN_SUPERCOMPAT_IF_YOU_SEE_THIS_ID',\n object: 'thread.run.step',\n run_id: run.id,\n assistant_id: run.assistant_id,\n thread_id: run.thread_id,\n type: 'tool_calls',\n status: 'in_progress',\n completed_at: null,\n created_at: dayjs().unix(),\n expired_at: null,\n last_error: null,\n metadata: {},\n failed_at: null,\n cancelled_at: null,\n usage: null,\n step_details: {\n type: 'tool_calls',\n tool_calls: [],\n },\n },\n })\n }\n\n onEvent({\n event: 'thread.run.step.delta',\n data: {\n object: 'thread.run.step.delta',\n run_id: run.id,\n id: toolCallsRunStep.id,\n delta: {\n step_details: {\n type: 'tool_calls',\n tool_calls: delta.tool_calls.map((tc: any) => ({\n id: uid(24),\n type: tc.type ?? 'function',\n ...tc,\n })),\n },\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent.ThreadRunStepDelta)\n\n currentToolCalls = toolCallsData({ prevToolCalls: currentToolCalls, delta })\n }\n\n if (delta.content) {\n onEvent({\n event: 'thread.message.delta',\n data: {\n id: message.id,\n delta: {\n content: [\n {\n type: 'text',\n index: 0,\n text: {\n value: delta.content,\n },\n },\n ],\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent.ThreadMessageDelta)\n }\n }\n\n message = await onEvent({\n event: 'thread.message.completed',\n data: {\n ...message,\n status: 'completed',\n content: [{ text: { value: currentContent, annotations: [] }, type: 'text' }],\n tool_calls: currentToolCalls,\n },\n })\n\n const messageToolCalls = (message.toolCalls ??\n []) as OpenAI.Beta.Threads.Runs.Steps.ToolCall[]\n\n const functionToolCalls = messageToolCalls.filter(\n (toolCall): toolCall is OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall =>\n toolCall.type === 'function'\n )\n\n const pendingFunctionToolCalls = functionToolCalls.filter(\n (toolCall) => !toolCall.function?.output\n )\n\n if (isEmpty(pendingFunctionToolCalls)) {\n if (toolCallsRunStep) {\n toolCallsRunStep = await onEvent({\n event: 'thread.run.step.completed',\n data: {\n ...toolCallsRunStep,\n status: 'completed',\n completed_at: dayjs().unix(),\n step_details: {\n type: 'tool_calls',\n tool_calls: currentToolCalls ?? [],\n },\n },\n })\n }\n\n return onEvent({\n event: 'thread.run.completed',\n data: {\n ...run,\n status: 'completed',\n completed_at: dayjs().unix(),\n },\n })\n }\n\n type RequiredToolCall =\n \| OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall\n \| {\n id: string\n type: 'computer_call'\n computer_call: {\n action: any\n pending_safety_checks: any[]\n }\n }\n\n const requiredToolCalls: RequiredToolCall[] = pendingFunctionToolCalls.map(\n (toolCall) => {\n const args = toolCall.function?.arguments ?? ''\n\n if (toolCall.function?.name === 'computer_call') {\n let parsedArguments: any = {}\n try {\n parsedArguments = JSON.parse(args \|\| '{}')\n } catch {\n parsedArguments = {}\n }\n\n const computerCall = {\n action:\n parsedArguments?.action ?? parsedArguments ?? {},\n pending_safety_checks:\n Array.isArray(parsedArguments?.pending_safety_checks)\n ? parsedArguments.pending_safety_checks\n : [],\n }\n\n return {\n id: toolCall.id,\n type: 'computer_call',\n computer_call: computerCall,\n }\n }\n\n return {\n id: toolCall.id,\n type: 'function',\n function: {\n name: toolCall.function?.name ?? '',\n arguments: args,\n },\n }\n }\n )\n\n return onEvent({\n event: 'thread.run.requires_action',\n data: {\n ...run,\n status: 'requires_action',\n required_action: {\n type: 'submit_tool_outputs',\n submit_tool_outputs: {\n tool_calls: requiredToolCalls as any,\n },\n },\n },\n })\n }\n }\n}\n","import type OpenAI from 'openai'\nimport { flat } from 'radash'\nimport { MessageWithRun } from '@/types'\nimport { serializeMessage } from './serializeMessage'\n\nexport const messages = async ({\n run,\n getMessages,\n}: {\n run: OpenAI.Beta.Threads.Run\n getMessages: () => Promise<MessageWithRun[]>\n}) => (\n [\n ...(run.instructions ? [{\n role: 'system',\n content: run.instructions,\n }] : []),\n ...flat((await getMessages()).map((message: MessageWithRun) => serializeMessage({ message }))),\n ]\n)\n","import type OpenAI from 'openai'\nimport { MessageWithRun } from '@/types'\nimport { isArray, isObject } from 'radash'\n\ntype ToolCall = OpenAI.Beta.Threads.Runs.Steps.ToolCall\n\nconst validToolCallContentTypes = [\n 'image',\n 'image_url',\n 'text',\n]\n\nconst serializeToolContent = ({\n toolCall,\n}: {\n toolCall: OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall\n}) => {\n if (isArray(toolCall.function.output)) {\n const isEveryToolPartValid = toolCall.function.output.every((toolPart) => {\n if (!isObject(toolPart)) return false\n\n return validToolCallContentTypes.includes((toolPart as any).type)\n })\n\n if (isEveryToolPartValid) {\n return toolCall.function.output\n }\n\n return JSON.stringify(toolCall.function.output)\n }\n\n return toolCall.function.output ?? ''\n}\n\nconst serializeToolCall = ({\n toolCall,\n}: {\n toolCall: OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall\n}) => ({\n tool_call_id: toolCall.id,\n role: 'tool' as 'tool',\n name: toolCall.function.name,\n content: serializeToolContent({\n toolCall,\n }),\n}) as OpenAI.ChatCompletionToolMessageParam\n\nconst serializeMessageWithContent = ({\n message,\n}: {\n message: MessageWithRun\n}) => ({\n role: message.role,\n content: serializeContent({\n content: message.content as unknown as OpenAI.Beta.Threads.Messages.TextContentBlock[],\n }),\n ...(message?.metadata?.toolCalls ? { tool_calls: message.metadata.toolCalls } : {}),\n}) as OpenAI.ChatCompletionMessageParam\n\nconst serializeContent = ({\n content,\n}: {\n content: OpenAI.Beta.Threads.Messages.TextContentBlock[]\n}) => content.map((content) => content.text.value).join('\\n')\n\nexport const serializeMessage = ({\n message\n}: {\n message: MessageWithRun\n}) => {\n const result = [serializeMessageWithContent({ message })] as OpenAI.ChatCompletionMessageParam[]\n\n const run = message.run\n\n if (!run) return result\n\n const messageToolCalls = (message.metadata?.toolCalls \|\| []) as OpenAI.Beta.Threads.Runs.Steps.ToolCall[]\n\n messageToolCalls.forEach((tc: OpenAI.Beta.Threads.Runs.Steps.ToolCall) => {\n const runStep = run.runSteps.find((rs) => {\n if (rs.type !== 'tool_calls') return false\n const stepDetails = rs.step_details as { tool_calls?: ToolCall[] }\n if (!Array.isArray(stepDetails.tool_calls)) return false\n\n return stepDetails.tool_calls.some((rsTc: ToolCall) => rsTc.type === 'function' && rsTc.id === tc.id)\n })\n\n if (!runStep) return\n\n const stepDetails = runStep.step_details as { tool_calls?: ToolCall[] }\n if (!Array.isArray(stepDetails.tool_calls)) return\n\n const toolCall = stepDetails.tool_calls.find((rsTc: ToolCall) => rsTc.type === 'function' && rsTc.id === tc.id)\n\n if (toolCall && toolCall.type === 'function') {\n result.push(serializeToolCall({ toolCall }))\n }\n })\n\n return result\n}\n","export const messagesRegexp = '^/(?:v1\|/?openai)/threads/([^/]+)/messages$'\n","export const runsRegexp = '^/(?:v1\|/?openai)/threads/([^/]+)/runs$'\n","export const runRegexp = '^/(?:v1\|/?openai)/threads/([^/]+)/runs/([^/]+)$'\n","export const submitToolOutputsRegexp = '^/(?:v1\|/?openai)/threads/([^/]+)/runs/([^/]+)/submit_tool_outputs$'\n","export const stepsRegexp = '^/(?:v1\|/?openai)/threads/([^/]+)/runs/([^/]+)/steps$'\n","import type OpenAI from 'openai'\nimport type { Prisma, PrismaClient } from '@prisma/client'\nimport dayjs from 'dayjs'\nimport { serializeThread } from './serializeThread'\n\ntype ThreadCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Thread>\n}\n\nexport const post = ({\n prisma,\n}: {\n prisma: PrismaClient\n}) => async (_urlString: string, options: RequestInit & { body?: string }): Promise<ThreadCreateResponse> => {\n if (!options.body) {\n throw new Error('No body provided')\n }\n\n const body = JSON.parse(options.body)\n\n const messages = (body.messages \|\| []) as OpenAI.Beta.ThreadCreateParams.Message[]\n const metadataRecord = (body.metadata \|\| {}) as Record<string, unknown>\n const assistantId = typeof metadataRecord.assistantId === 'string'\n ? metadataRecord.assistantId\n : undefined\n\n if (!assistantId) {\n throw new Error('assistantId is required to create a thread')\n }\n\n const initialCreatedAt = dayjs().subtract(messages.length, 'seconds')\n\n const messageData = messages.map((message, index) => ({\n role: message.role === 'user' ? 'USER' : 'ASSISTANT',\n content: [\n {\n type: 'text',\n text: {\n annotations: [],\n value: message.content,\n },\n },\n ] as Prisma.InputJsonValue,\n attachments: (message.attachments ?? []) as Prisma.InputJsonValue[],\n metadata: message.metadata as Prisma.InputJsonValue \| undefined,\n createdAt: initialCreatedAt.add(index, 'seconds').toDate(),\n })) satisfies Prisma.MessageCreateWithoutThreadInput[]\n\n const threadData = {\n metadata: metadataRecord as Prisma.InputJsonValue,\n assistant: {\n connect: {\n id: assistantId,\n },\n },\n messages: {\n create: messageData,\n },\n } satisfies Prisma.ThreadCreateInput\n\n const thread = await prisma.thread.create({\n data: threadData,\n })\n\n return new Response(JSON.stringify(\n serializeThread({ thread }),\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n}\n","// @ts-ignore-next-line\nimport type { Thread } from '@prisma/client'\nimport dayjs from 'dayjs'\n\nexport const serializeThread = ({\n thread,\n}: {\n thread: Thread\n}) => ({\n id: thread.id,\n object: 'thread' as 'thread',\n created_at: dayjs(thread.createdAt).unix(),\n metadata: thread.metadata,\n // TODO\n tool_resources: null,\n})\n","import type { PrismaClient } from '@prisma/client'\nimport { post } from './post'\nimport type { RequestHandler } from '@/types'\n\nexport const threads = ({\n prisma,\n}: {\n prisma: PrismaClient\n}): { post: RequestHandler } => ({\n post: post({ prisma }),\n})\n","import type OpenAI from 'openai'\nimport { isArray } from 'radash'\nimport type { Prisma, PrismaClient } from '@prisma/client'\nimport { serializeMessage } from './serializeMessage'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\n\ntype MessageCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Messages.Message>\n}\n\nconst messageContentBlocks = ({\n content,\n}: {\n content: string \| OpenAI.Beta.Threads.Messages.MessageContentPartParam[]\n}) => {\n if (isArray(content)) {\n return content.map((item) => {\n if (item.type === 'text') {\n return {\n type: 'text',\n text: {\n value: item.text ?? '',\n annotations: [],\n },\n }\n }\n\n return item\n })\n }\n\n return [\n {\n type: 'text',\n text: {\n value: content ?? '',\n annotations: [],\n },\n },\n ]\n}\n\nexport const post = ({\n prisma,\n}: {\n prisma: PrismaClient\n}) => async (urlString: string, options: RequestInit & { body?: string }): Promise<MessageCreateResponse> => {\n const url = new URL(urlString)\n\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp))!\n\n if (!options.body) {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const { role, content, metadata } = body\n\n const message = await prisma.message.create({\n data: {\n threadId,\n content: messageContentBlocks({ content }) as Prisma.InputJsonValue,\n role: (role === 'user' ? 'USER' : 'ASSISTANT') as Prisma.MessageCreateWithoutThreadInput['role'],\n metadata: (metadata ?? {}) as Prisma.InputJsonValue,\n },\n })\n\n return new Response(JSON.stringify(\n serializeMessage({ message }),\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n}\n","// @ts-ignore-next-line\nimport type { Message } from '@prisma/client'\nimport dayjs from 'dayjs'\nimport type OpenAI from 'openai'\nimport { assign } from 'radash'\n\nexport const serializeMessage = ({\n message,\n}: {\n message: Message\n}) => ({\n id: message.id,\n object: 'thread.message' as 'thread.message',\n created_at: dayjs(message.createdAt).unix(),\n thread_id: message.threadId,\n completed_at: message.completedAt ? dayjs(message.completedAt).unix() : null,\n incomplete_at: message.incompleteAt ? dayjs(message.incompleteAt).unix() : null,\n incomplete_details: message.incompleteDetails as unknown as OpenAI.Beta.Threads.Messages.Message.IncompleteDetails,\n role: message.role.toLowerCase() as 'user' \| 'assistant',\n content: message.content as unknown as OpenAI.Beta.Threads.Messages.TextContentBlock[],\n assistant_id: message.assistantId,\n run_id: message.runId,\n attachments: message.attachments as OpenAI.Beta.Threads.Messages.Message['attachments'],\n status: message.status.toLowerCase() as OpenAI.Beta.Threads.Messages.Message['status'],\n metadata: assign(message.metadata as Record<any, any> ?? {}, message.toolCalls ? { toolCalls: message.toolCalls } : {}),\n})\n","import type OpenAI from 'openai'\n// @ts-ignore-next-line\nimport type { PrismaClient, Message } from '@prisma/client'\nimport { assign, last } from 'radash'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\nimport { serializeMessage } from './serializeMessage'\n\ntype MessageCreateResponse = Response & {\n json: () => Promise<ReturnType<OpenAI.Beta.Threads.Messages['create']>>\n}\n\nexport const get = ({\n prisma,\n}: {\n prisma: PrismaClient\n}) => async (urlString: string): Promise<MessageCreateResponse> => {\n const url = new URL(urlString)\n\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp))!\n\n const {\n limit,\n order,\n after,\n } = assign({\n limit: '20',\n order: 'desc',\n // after: null,\n }, Object.fromEntries(url.searchParams))\n\n const pageSize = parseInt(limit)\n\n const messagesPlusOne = await prisma.message.findMany({\n where: { threadId },\n take: pageSize + 1,\n orderBy: { createdAt: order === 'asc' ? 'asc' : 'desc' },\n ...(after && {\n skip: 1,\n cursor: { id: after },\n }),\n }) as Message[]\n\n const messages = messagesPlusOne.slice(0, pageSize)\n\n return new Response(JSON.stringify({\n data: messages.map((message: Message) => (\n serializeMessage({ message })\n )),\n has_more: messagesPlusOne.length > pageSize,\n last_id: last(messages)?.id ?? null,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n}\n","import type { PrismaClient } from '@prisma/client'\nimport { post } from './post'\nimport { get } from './get'\nimport type { RequestHandler } from '@/types'\n\nexport const messages = ({\n prisma,\n}: {\n prisma: PrismaClient\n}): { post: RequestHandler; get: RequestHandler } => ({\n post: post({ prisma }),\n get: get({ prisma }),\n})\n","import type OpenAI from 'openai'\nimport type { PrismaClient, Run as PrismaRun } from '@prisma/client'\nimport { assign } from 'radash'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { serializeRun } from './serializeRun'\nimport { mapPrismaRun } from './mapPrismaRun'\n\ntype MessageCreateResponse = Response & {\n json: () => Promise<ReturnType<OpenAI.Beta.Threads.Messages['create']>>\n}\n\nexport const get = ({\n prisma,\n}: {\n prisma: PrismaClient\n}) => async (urlString: string): Promise<MessageCreateResponse> => {\n const url = new URL(urlString)\n\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp))!\n\n const {\n limit,\n order,\n after,\n } = assign({\n limit: '20',\n order: 'desc',\n // after: null,\n }, Object.fromEntries(url.searchParams))\n\n const pageSize = parseInt(limit, 10)\n\n const runsPlusOne = await prisma.run.findMany({\n where: { threadId },\n take: pageSize + 1,\n orderBy: { createdAt: order === 'asc' ? 'asc' : 'desc' },\n ...(after && {\n skip: 1,\n cursor: { id: after },\n }),\n }) as PrismaRun[]\n\n const runs = runsPlusOne.slice(0, pageSize)\n\n return new Response(JSON.stringify({\n data: runs.map((run) => serializeRun({ run: mapPrismaRun(run) })),\n has_more: runsPlusOne.length > pageSize,\n last_id: runs.at(-1)?.id ?? null,\n }), {\n status: 200,\n headers: { 'Content-Type': 'application/json' },\n })\n}\n","import type OpenAI from 'openai'\nimport type { Run } from '@/types/prisma'\nimport dayjs from 'dayjs'\n\nexport const serializeRun = ({\n run,\n}: {\n run: Run\n}): OpenAI.Beta.Threads.Run => ({\n id: run.id,\n object: 'thread.run' as 'thread.run',\n created_at: dayjs(run.createdAt).unix(),\n thread_id: run.threadId,\n assistant_id: run.assistantId,\n status: run.status.toLowerCase() as OpenAI.Beta.Threads.Run['status'],\n required_action: run.requiredAction as OpenAI.Beta.Threads.Run['required_action'],\n last_error: run.lastError as OpenAI.Beta.Threads.Run['last_error'],\n expires_at: dayjs(run.expiresAt).unix(),\n started_at: run.startedAt ? dayjs(run.startedAt).unix() : null,\n cancelled_at: run.cancelledAt ? dayjs(run.cancelledAt).unix() : null,\n failed_at: run.failedAt ? dayjs(run.failedAt).unix() : null,\n completed_at: run.completedAt ? dayjs(run.completedAt).unix() : null,\n model: run.model,\n instructions: run.instructions,\n tools: run.tools as unknown as OpenAI.Beta.Threads.Run['tools'],\n metadata: run.metadata as unknown as OpenAI.Beta.Threads.Run['metadata'],\n usage: run.usage as OpenAI.Beta.Threads.Run['usage'],\n truncation_strategy: {\n type: 'auto',\n },\n response_format: {\n type: 'text',\n },\n // TODO\n incomplete_details: null,\n max_completion_tokens: null,\n max_prompt_tokens: null,\n tool_choice: 'auto',\n parallel_tool_calls: true,\n})\n","import type { Prisma, Run as PrismaRun, RunStep as PrismaRunStep } from '@prisma/client'\nimport {\n RunStatus,\n RunStepStatus,\n RunStepType,\n type Run,\n type RunStep,\n} from '@/types/prisma'\n\nexport const mapPrismaRun = (run: PrismaRun): Run => ({\n id: run.id,\n threadId: run.threadId,\n assistantId: run.assistantId,\n status: run.status as RunStatus,\n requiredAction: run.requiredAction as Prisma.JsonValue \| null,\n lastError: run.lastError as Prisma.JsonValue \| null,\n expiresAt: run.expiresAt,\n startedAt: run.startedAt ?? null,\n cancelledAt: run.cancelledAt ?? null,\n failedAt: run.failedAt ?? null,\n completedAt: run.completedAt ?? null,\n model: run.model,\n instructions: run.instructions,\n tools: run.tools as Prisma.JsonValue[],\n metadata: run.metadata as Prisma.JsonValue \| null,\n usage: run.usage as Prisma.JsonValue \| null,\n truncationStrategy: run.truncationStrategy as Prisma.JsonValue,\n responseFormat: run.responseFormat as Prisma.JsonValue,\n createdAt: run.createdAt,\n updatedAt: run.updatedAt,\n})\n\nexport const mapPrismaRunStep = (runStep: PrismaRunStep): RunStep => ({\n id: runStep.id,\n threadId: runStep.threadId,\n assistantId: runStep.assistantId,\n runId: runStep.runId,\n type: runStep.type as RunStepType,\n status: runStep.status as RunStepStatus,\n stepDetails: runStep.stepDetails as Prisma.JsonValue,\n lastError: runStep.lastError as Prisma.JsonValue \| null,\n expiredAt: runStep.expiredAt ?? null,\n cancelledAt: runStep.cancelledAt ?? null,\n failedAt: runStep.failedAt ?? null,\n completedAt: runStep.completedAt ?? null,\n metadata: runStep.metadata as Prisma.JsonValue \| null,\n usage: runStep.usage as Prisma.JsonValue \| null,\n createdAt: runStep.createdAt,\n updatedAt: runStep.updatedAt,\n})\n","import type OpenAI from 'openai'\nimport type { PrismaClient } from '@prisma/client'\nimport dayjs from 'dayjs'\nimport { assign } from 'radash'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { serializeRun } from './serializeRun'\nimport { RunAdapterPartobClient } from '@/types'\nimport { onEvent } from './onEvent'\nimport { getMessages } from './getMessages'\nimport type { Run } from '@/types/prisma'\n\ntype RunCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Run>\n}\n\nexport const post = ({\n prisma,\n runAdapter,\n}: {\n prisma: PrismaClient\n runAdapter: RunAdapterPartobClient\n}) => async (urlString: string, options: RequestInit & { body?: string }): Promise<RunCreateResponse> => {\n const url = new URL(urlString)\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp))!\n\n if (!options.body) {\n throw new Error('No body provided')\n }\n\n const body = JSON.parse(options.body)\n const { assistant_id, stream } = body\n\n const assistant = await prisma.assistant.findUnique({\n where: {\n id: assistant_id,\n },\n })\n\n if (!assistant) {\n throw new Error('Assistant not found')\n }\n\n const {\n model,\n instructions,\n // additional_instructions,\n tools,\n metadata,\n response_format,\n truncation_strategy,\n } = assign({\n model: assistant.modelSlug,\n instructions: '',\n additional_instructions: null,\n truncation_strategy: {\n type: 'auto',\n },\n response_format: {\n type: 'text',\n },\n // tools: [],\n // metadata: {},\n }, body)\n\n const run = await prisma.run.create({\n data: {\n status: 'QUEUED',\n expiresAt: dayjs().add(1, 'hour').unix(),\n model,\n instructions,\n tools,\n metadata,\n thread: {\n connect: {\n id: threadId,\n },\n },\n assistant: {\n connect: {\n id: assistant_id,\n },\n },\n truncationStrategy: truncation_strategy,\n responseFormat: response_format,\n },\n }) as Run\n\n const data = serializeRun({ run })\n\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n run: data,\n onEvent: onEvent({\n controller: {\n ...controller,\n enqueue: (data) => {\n controller.enqueue(`data: ${JSON.stringify(data)}\\n\\n`)\n },\n },\n prisma,\n }),\n getMessages: getMessages({\n prisma,\n run,\n }),\n })\n } catch (error: any) {\n console.error(error)\n\n onEvent({\n controller: {\n ...controller,\n enqueue: (data) => {\n controller.enqueue(`data: ${JSON.stringify(data)}\\n\\n`)\n },\n },\n prisma,\n })({\n event: 'thread.run.failed',\n data: {\n id: run.id,\n failed_at: dayjs().unix(),\n last_error: {\n code: 'server_error',\n message: `${error?.message ?? ''} ${error?.cause?.message ?? ''}`,\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent.ThreadRunFailed)\n }\n\n controller.close()\n },\n })\n\n if (stream) {\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n return new Response(JSON.stringify(\n data\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type OpenAI from 'openai'\nimport { RunStatus } from '@/types/prisma'\nimport type { PrismaClient } from '@prisma/client'\n\nexport const threadRunInProgress = ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadRunInProgress\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadRunInProgress>\n}) => {\n controller.enqueue(event)\n\n return prisma.run.update({\n where: {\n id: event.data.id,\n },\n data: {\n status: RunStatus.IN_PROGRESS,\n },\n })\n}\n","import type OpenAI from 'openai'\nimport { RunStatus } from '@/types/prisma'\nimport type { Prisma, PrismaClient } from '@prisma/client'\n\nexport const threadRunFailed = ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadRunFailed\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadRunFailed>\n}) => {\n controller.enqueue(event)\n\n return prisma.run.update({\n where: {\n id: event.data.id,\n },\n data: {\n status: RunStatus.FAILED as Prisma.RunUpdateInput['status'],\n failedAt: event.data.failed_at,\n ...(event.data.last_error != null\n ? { lastError: event.data.last_error as unknown as Prisma.InputJsonValue }\n : {}),\n },\n })\n}\n","import type OpenAI from 'openai'\nimport { RunStatus } from '@/types/prisma'\nimport type { PrismaClient } from '@prisma/client'\n\nexport const threadRunCompleted = ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadRunCompleted\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadRunCompleted>\n}) => {\n controller.enqueue(event)\n\n return prisma.run.update({\n where: {\n id: event.data.id,\n },\n data: {\n status: RunStatus.COMPLETED,\n requiredAction: undefined,\n },\n })\n}\n","import type OpenAI from 'openai'\nimport { RunStatus } from '@/types/prisma'\nimport type { Prisma, PrismaClient } from '@prisma/client'\n\nexport const threadRunRequiresAction = ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadRunRequiresAction\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadRunRequiresAction>\n}) => {\n controller.enqueue(event)\n\n return prisma.run.update({\n where: {\n id: event.data.id,\n },\n data: {\n status: RunStatus.REQUIRES_ACTION as Prisma.RunUpdateInput['status'],\n ...(event.data.required_action != null\n ? { requiredAction: event.data.required_action as unknown as Prisma.InputJsonValue }\n : {}),\n },\n })\n}\n","import dayjs from 'dayjs'\n// @ts-ignore-next-line\nimport type { RunStep } from '@prisma/client'\nimport type OpenAI from 'openai'\n\nexport const serializeRunStep = ({\n runStep,\n}: {\n runStep: RunStep\n}) => ({\n id: runStep.id,\n object: 'thread.run.step' as 'thread.run.step',\n created_at: dayjs(runStep.createdAt).unix(),\n assistant_id: runStep.assistantId,\n thread_id: runStep.threadId,\n run_id: runStep.runId,\n type: runStep.type.toLowerCase() as OpenAI.Beta.Threads.Runs.RunStep['type'],\n status: runStep.status.toLowerCase() as OpenAI.Beta.Threads.Runs.RunStep['status'],\n // @ts-ignore-next-line\n step_details: runStep.stepDetails as OpenAI.Beta.Threads.Runs.RunStep['step_details'],\n last_error: runStep.lastError as OpenAI.Beta.Threads.Runs.RunStep['last_error'],\n expired_at: runStep.expiredAt ? dayjs(runStep.expiredAt).unix() : null,\n cancelled_at: runStep.cancelledAt ? dayjs(runStep.cancelledAt).unix() : null,\n failed_at: runStep.failedAt ? dayjs(runStep.failedAt).unix() : null,\n completed_at: runStep.completedAt ? dayjs(runStep.completedAt).unix() : null,\n metadata: runStep.metadata,\n usage: runStep.usage as OpenAI.Beta.Threads.Runs.RunStep['usage'],\n})\n","import type OpenAI from 'openai'\nimport { RunStepStatus, RunStepType } from '@/types/prisma'\nimport type { Prisma, PrismaClient } from '@prisma/client'\nimport { serializeRunStep } from '../../steps/serializeRunStep'\n\nconst type = (event: OpenAI.Beta.AssistantStreamEvent.ThreadRunStepCreated) => {\n if (event.data.type === 'message_creation') return RunStepType.MESSAGE_CREATION\n if (event.data.type === 'tool_calls') return RunStepType.TOOL_CALLS\n\n throw new Error(`Unknown type: ${event.data.type}`)\n}\n\nconst status = (event: OpenAI.Beta.AssistantStreamEvent.ThreadRunStepCreated) => {\n if (event.data.status === 'in_progress') return RunStepStatus.IN_PROGRESS\n if (event.data.status === 'cancelled') return RunStepStatus.CANCELLED\n if (event.data.status === 'completed') return RunStepStatus.COMPLETED\n if (event.data.status === 'failed') return RunStepStatus.FAILED\n if (event.data.status === 'expired') return RunStepStatus.EXPIRED\n\n throw new Error(`Unknown status: ${event.data.status}`)\n}\n\nexport const threadRunStepCreated = async ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadRunStepCreated\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadRunStepCreated>\n}): Promise<OpenAI.Beta.Threads.Runs.RunStep> => {\n const runStep = await prisma.runStep.create({\n data: {\n runId: event.data.run_id,\n assistantId: event.data.assistant_id,\n threadId: event.data.thread_id,\n type: type(event) as Prisma.RunStepCreateInput['type'],\n status: status(event) as Prisma.RunStepCreateInput['status'],\n stepDetails: event.data.step_details as unknown as Prisma.InputJsonValue,\n completedAt: event.data.completed_at,\n },\n })\n\n const serializedRunStep = serializeRunStep({ runStep })\n\n controller.enqueue({\n ...event,\n data: serializedRunStep,\n } as OpenAI.Beta.AssistantStreamEvent.ThreadRunStepCreated)\n\n return serializedRunStep as OpenAI.Beta.Threads.Runs.RunStep\n}\n","import type OpenAI from 'openai'\n\nexport const threadRunStepDelta = ({\n event,\n controller,\n}: {\n event: OpenAI.Beta.AssistantStreamEvent.ThreadRunStepDelta\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadRunStepDelta>\n}) => (\n controller.enqueue(event)\n)\n","import type OpenAI from 'openai'\nimport { RunStepStatus } from '@/types/prisma'\nimport type { Prisma, PrismaClient } from '@prisma/client'\n\nexport const threadRunStepCompleted = async ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadRunStepCompleted\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadRunStepCompleted>\n}) => {\n controller.enqueue(event)\n\n await prisma.runStep.update({\n where: {\n id: event.data.id,\n },\n data: {\n status: RunStepStatus.COMPLETED as Prisma.RunStepUpdateInput['status'],\n stepDetails: event.data.step_details as unknown as Prisma.InputJsonValue,\n completedAt: event.data.completed_at,\n },\n })\n}\n","import type OpenAI from 'openai'\nimport { MessageRole, MessageStatus } from '@/types/prisma'\nimport type { Prisma, PrismaClient } from '@prisma/client'\nimport { serializeMessage } from '../../../messages/serializeMessage'\n\nconst status = (event: OpenAI.Beta.AssistantStreamEvent.ThreadMessageCreated) => {\n if (event.data.status === 'completed') return MessageStatus.COMPLETED\n if (event.data.status === 'in_progress') return MessageStatus.IN_PROGRESS\n if (event.data.status === 'incomplete') return MessageStatus.INCOMPLETE\n\n throw new Error(`Unknown status: ${event.data.status}`)\n}\n\nexport const threadMessageCreated = async ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadMessageCreated\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadMessageCreated>\n}) => {\n const message = await prisma.message.create({\n data: {\n threadId: event.data.thread_id,\n content: event.data.content as unknown as Prisma.InputJsonValue,\n role: (event.data.role === 'assistant'\n ? MessageRole.ASSISTANT\n : MessageRole.USER) as Prisma.MessageCreateWithoutThreadInput['role'],\n assistantId: event.data.assistant_id,\n runId: event.data.run_id,\n status: status(event) as Prisma.MessageCreateWithoutThreadInput['status'],\n },\n })\n\n const serializedMessage = serializeMessage({ message })\n\n controller.enqueue({\n ...event,\n data: serializedMessage,\n })\n\n return serializedMessage\n}\n","import type OpenAI from 'openai'\n\nexport const threadMessageDelta = ({\n event,\n controller,\n}: {\n event: OpenAI.Beta.AssistantStreamEvent.ThreadMessageDelta\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadMessageDelta>\n}) => (\n controller.enqueue(event)\n)\n","import type OpenAI from 'openai'\nimport { MessageStatus, RunStepType } from '@/types/prisma'\nimport type { Prisma, PrismaClient } from '@prisma/client'\n\nexport const threadMessageCompleted = async ({\n prisma,\n event,\n controller,\n}: {\n prisma: PrismaClient\n event: OpenAI.Beta.AssistantStreamEvent.ThreadMessageCompleted\n controller: ReadableStreamDefaultController<OpenAI.Beta.AssistantStreamEvent.ThreadMessageCompleted>\n}) => {\n controller.enqueue(event)\n\n const toolCalls = (event.data as { tool_calls?: unknown }).tool_calls\n\n if (toolCalls !== undefined) {\n const latestRunStep = await prisma.runStep.findFirst({\n where: {\n threadId: event.data.thread_id,\n type: RunStepType.TOOL_CALLS,\n },\n orderBy: {\n createdAt: 'desc',\n },\n })\n\n if (!latestRunStep) {\n throw new Error('No run step found')\n }\n\n await prisma.runStep.update({\n where: {\n id: latestRunStep.id,\n },\n data: {\n stepDetails: {\n type: 'tool_calls',\n tool_calls: toolCalls,\n } as Prisma.InputJsonValue,\n },\n })\n }\n return prisma.message.update({\n where: {\n id: event.data.id,\n },\n data: {\n status: MessageStatus.COMPLETED as Prisma.MessageUpdateInput['status'],\n ...(event.data.content\n ? { content: event.data.content as unknown as Prisma.InputJsonValue }\n : {}),\n ...(toolCalls !== undefined\n ? { toolCalls: toolCalls as Prisma.InputJsonValue }\n : {}),\n },\n })\n}\n","import { threadRunInProgress } from './threadRunInProgress'\nimport { threadRunFailed } from './threadRunFailed'\nimport { threadRunCompleted } from './threadRunCompleted'\nimport { threadRunRequiresAction } from './threadRunRequiresAction'\nimport { threadRunStepCreated } from './threadRunStepCreated'\nimport { threadRunStepDelta } from './threadRunStepDelta'\nimport { threadRunStepCompleted } from './threadRunStepCompleted'\nimport { threadMessageCreated } from './threadMessageCreated'\nimport { threadMessageDelta } from './threadMessageDelta'\nimport { threadMessageCompleted } from './threadMessageCompleted'\n\nexport const handlers = {\n 'thread.run.in_progress': threadRunInProgress,\n 'thread.run.failed': threadRunFailed,\n 'thread.run.completed': threadRunCompleted,\n 'thread.run.requires_action': threadRunRequiresAction,\n 'thread.run.step.created': threadRunStepCreated,\n 'thread.run.step.delta': threadRunStepDelta,\n 'thread.run.step.completed': threadRunStepCompleted,\n 'thread.message.created': threadMessageCreated,\n 'thread.message.delta': threadMessageDelta,\n 'thread.message.completed': threadMessageCompleted,\n}\n","import type OpenAI from 'openai'\nimport type { PrismaClient } from '@prisma/client'\nimport { handlers } from './handlers'\n\nexport const onEvent = ({\n prisma,\n controller,\n}: {\n prisma: PrismaClient\n controller: ReadableStreamDefaultController\n}) => (event: OpenAI.Beta.AssistantStreamEvent) => {\n // @ts-ignore-next-line\n const handler = handlers[event.event]\n\n if (!handler) {\n console.log('No handler for event', event)\n return\n }\n\n return handler({ prisma, controller, event })\n}\n","import type { PrismaClient, Run as PrismaRun } from '@prisma/client'\nimport { serializeMessage } from '../messages/serializeMessage'\nimport { serializeRunStep } from './steps/serializeRunStep'\nimport { serializeRun } from './serializeRun'\nimport type { Run } from '@/types/prisma'\nimport type { MessageWithRun } from '@/types'\nimport { mapPrismaRun } from './mapPrismaRun'\n\nconst getTake = ({\n run,\n}: {\n run: Run\n}) => {\n // @ts-ignore-next-line\n if (['auto', 'disabled'].includes(run.truncationStrategy.type)) {\n return null\n }\n\n // @ts-ignore-next-line\n if (run.truncationStrategy.type === 'last_messages') {\n // @ts-ignore-next-line\n if (!run.truncationStrategy.last_messages) {\n throw new Error('Truncation strategy last_messages is required')\n }\n\n // @ts-ignore-next-line\n return -run.truncationStrategy.last_messages\n }\n\n // @ts-ignore-next-line\n throw new Error(`Unsupported truncation strategy type: ${run.truncationStrategy.type}`)\n}\n\nexport const getMessages = ({\n prisma,\n run,\n}: {\n prisma: PrismaClient\n run: Run\n}) => async () => {\n const take = getTake({\n run,\n })\n\n const messages = await prisma.message.findMany({\n where: {\n threadId: run.threadId,\n },\n include: {\n run: {\n include: {\n runSteps: true,\n },\n },\n },\n orderBy: {\n createdAt: 'asc',\n },\n ...(take ? { take } : {}),\n })\n\n return messages.map((message) => ({\n ...serializeMessage({ message }),\n run: message.run\n ? {\n ...serializeRun({ run: mapPrismaRun(message.run as PrismaRun) }),\n runSteps: message.run.runSteps.map((runStep) => (\n serializeRunStep({ runStep })\n )),\n }\n : null,\n })) as MessageWithRun[]\n}\n","import type { PrismaClient } from '@prisma/client'\nimport type { RequestHandler, RunAdapterPartobClient } from '@/types'\nimport { get } from './get'\nimport { post } from './post'\n\nexport const runs = ({\n prisma,\n runAdapter,\n}: {\n prisma: PrismaClient\n runAdapter: RunAdapterPartobClient\n}): { get: RequestHandler; post: RequestHandler } => ({\n get: get({ prisma }),\n post: post({ prisma, runAdapter }),\n})\n","import type OpenAI from 'openai'\nimport type { PrismaClient } from '@prisma/client'\nimport { runRegexp } from '@/lib/runs/runRegexp'\nimport { serializeRun } from '../runs/serializeRun'\nimport { mapPrismaRun } from '../runs/mapPrismaRun'\n\ntype GetResponse = Response & {\n json: () => Promise<ReturnType<OpenAI.Beta.Threads.Runs['retrieve']>>\n}\n\nexport const get = ({\n prisma,\n}: {\n prisma: PrismaClient\n}) => async (urlString: string): Promise<GetResponse> => {\n const url = new URL(urlString)\n\n const [, threadId, runId] = url.pathname.match(new RegExp(runRegexp))!\n\n const run = await prisma.run.findUnique({\n where: {\n id: runId,\n threadId,\n },\n })\n\n if (!run) {\n return new Response(JSON.stringify({ error: 'Not Found' }), {\n status: 404,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n\n return new Response(JSON.stringify(\n serializeRun({ run: mapPrismaRun(run) })\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n 'openai-poll-after-ms': '5000',\n },\n })\n}\n","import type { PrismaClient } from '@prisma/client'\nimport type { RequestHandler, RunAdapterPartobClient } from '@/types'\nimport { get } from './get'\n// import { post } from './post'\n\nexport const run = ({\n prisma,\n runAdapter,\n}: {\n prisma: PrismaClient\n runAdapter: RunAdapterPartobClient\n}): { get: RequestHandler } => ({\n get: get({ prisma }),\n // post: post({ prisma, runAdapter }),\n})\n","import type { PrismaClient, RunStep } from '@prisma/client'\nimport { assign } from 'radash'\nimport { stepsRegexp } from '@/lib/steps/stepsRegexp'\nimport { serializeRunStep } from './serializeRunStep'\n\nexport const get = ({\n prisma,\n}: {\n prisma: PrismaClient\n}) => async (urlString: string) => {\n const url = new URL(urlString)\n\n const [, threadId, runId] = url.pathname.match(new RegExp(stepsRegexp))!\n\n const {\n limit,\n order,\n after,\n } = assign({\n limit: '20',\n order: 'desc',\n // after: null,\n }, Object.fromEntries(url.searchParams))\n\n const pageSize = parseInt(limit, 10)\n\n const runStepsPlusOne = await prisma.runStep.findMany({\n where: { threadId, runId },\n take: pageSize + 1,\n orderBy: { createdAt: order as 'asc' \| 'desc' },\n ...(after && {\n skip: 1,\n cursor: { id: after },\n }),\n }) as RunStep[]\n\n const runSteps = runStepsPlusOne.slice(0, pageSize)\n\n return new Response(JSON.stringify({\n data: runSteps.map((runStep: RunStep) => serializeRunStep({ runStep })),\n has_more: runStepsPlusOne.length > pageSize,\n last_id: runSteps.at(-1)?.id ?? null,\n }), {\n status: 200,\n headers: { 'Content-Type': 'application/json' },\n })\n}\n","import type { PrismaClient } from '@prisma/client'\nimport { get } from './get'\nimport type { RequestHandler } from '@/types'\n\nexport const steps = ({\n prisma,\n}: {\n prisma: PrismaClient\n}): { get: RequestHandler } => ({\n get: get({ prisma }),\n})\n","import type OpenAI from 'openai'\nimport type { PrismaClient } from '@prisma/client'\nimport dayjs from 'dayjs'\nimport type { Run } from '@/types/prisma'\n\nexport const updateRun = async ({\n prisma,\n runId,\n threadId,\n onThreadRunStepCompleted = () => {},\n tool_outputs,\n}: {\n prisma: PrismaClient\n runId: string\n threadId: string\n onThreadRunStepCompleted?: ({ runStep }: { runStep: any }) => void\n tool_outputs: OpenAI.Beta.Threads.RunSubmitToolOutputsParams['tool_outputs']\n}) => (\n // @ts-expect-error prisma transaction typing is broken\n prisma.$transaction(async (prisma: PrismaClient) => {\n const runSteps = await prisma.runStep.findMany({\n where: {\n threadId,\n runId,\n type: 'TOOL_CALLS',\n status: 'IN_PROGRESS',\n },\n orderBy: {\n createdAt: 'asc',\n },\n })\n\n for (const runStep of runSteps) {\n const completedRunStep = await prisma.runStep.update({\n where: {\n id: runStep.id,\n },\n data: {\n status: 'COMPLETED',\n completedAt: dayjs().unix(),\n stepDetails: {\n type: 'tool_calls',\n // @ts-ignore-next-line\n tool_calls: runStep.stepDetails!.tool_calls.map((toolCall) => {\n // @ts-ignore-next-line\n const toolOutput = tool_outputs.find((output) => output.tool_call_id === toolCall.id) \|\| tool_outputs[0]\n\n if (!toolOutput) {\n console.dir({ toolOutput, runStep, tool_outputs, runSteps }, { depth: null })\n throw new Error('Tool output not found')\n }\n\n return {\n id: toolCall.id,\n type: toolCall.type,\n function: {\n ...toolCall.function,\n output: toolOutput.output,\n },\n }\n }),\n },\n },\n })\n\n onThreadRunStepCompleted({\n runStep: completedRunStep,\n })\n }\n\n return prisma.run.update({\n where: {\n id: runId,\n },\n data: {\n status: 'QUEUED',\n },\n })\n }) as Promise<Run>\n)\n","import type { PrismaClient } from '@prisma/client'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { RunAdapterPartobClient } from '@/types'\nimport { serializeRun } from '../../serializeRun'\nimport { onEvent } from '../../onEvent'\nimport { getMessages } from '../../getMessages'\nimport { serializeRunStep } from '../../steps/serializeRunStep'\nimport { updateRun } from './updateRun'\n\nexport const post = ({\n prisma,\n runAdapter,\n}: {\n prisma: PrismaClient\n runAdapter: RunAdapterPartobClient\n}) => async (urlString: string, options: any) => {\n const url = new URL(urlString)\n const [, threadId, runId] = url.pathname.match(new RegExp(submitToolOutputsRegexp))!\n\n const body = JSON.parse(options.body)\n\n const {\n tool_outputs,\n stream,\n } = body\n\n if (stream) {\n const readableStream = new ReadableStream({\n async start(controller) {\n const run = await updateRun({\n prisma,\n runId,\n threadId,\n tool_outputs,\n onThreadRunStepCompleted: async ({ runStep }) => {\n controller.enqueue(`data: ${JSON.stringify({\n event: 'thread.run.step.completed',\n data: serializeRunStep({ runStep }),\n })}\\n\\n`)\n }\n })\n\n await runAdapter.handleRun({\n run: serializeRun({ run }),\n onEvent: onEvent({\n controller: {\n ...controller,\n enqueue: (data) => {\n controller.enqueue(`data: ${JSON.stringify(data)}\\n\\n`)\n },\n },\n prisma,\n }),\n getMessages: getMessages({ prisma, run }),\n })\n\n controller.close()\n },\n })\n\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n const run = await updateRun({\n prisma,\n runId,\n threadId,\n tool_outputs,\n })\n\n await new Promise((resolve) => (\n new ReadableStream({\n async start(controller) {\n await runAdapter.handleRun({\n run: serializeRun({ run }),\n onEvent: onEvent({\n controller: {\n ...controller,\n enqueue: (data) => {\n controller.enqueue(`data: ${JSON.stringify(data)}\\n\\n`)\n },\n },\n prisma,\n }),\n getMessages: getMessages({ prisma, run }),\n })\n\n controller.close()\n resolve(void 0)\n },\n })\n ))\n\n return new Response(JSON.stringify(\n run\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type { PrismaClient } from '@prisma/client'\nimport type { RequestHandler, RunAdapterPartobClient } from '@/types'\nimport { post } from './post'\n\nexport const submitToolOutputs = ({\n prisma,\n runAdapter,\n}: {\n prisma: PrismaClient\n runAdapter: RunAdapterPartobClient\n}): { post: RequestHandler } => ({\n post: post({\n prisma,\n // @ts-ignore-next-line\n runAdapter,\n }),\n})\n","import type { PrismaClient } from '@prisma/client'\nimport dayjs from 'dayjs'\n\nexport const post = ({ prisma }: { prisma: PrismaClient }) =>\n async (_url: string, options: RequestInit & { body?: string }) => {\n if (!options.body) {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const { model, instructions } = body\n\n const assistant = await prisma.assistant.create({\n data: { modelSlug: model, instructions },\n })\n\n const data = {\n id: assistant.id,\n object: 'assistant',\n created_at: dayjs().unix(),\n name: null,\n description: null,\n model,\n instructions,\n tools: [],\n metadata: {},\n }\n\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import type { PrismaClient } from '@prisma/client'\nimport { post } from './post'\nimport type { RequestHandler } from '@/types'\n\nexport const assistants = ({ prisma }: { prisma: PrismaClient }): { post: RequestHandler } => ({\n post: post({ prisma }),\n})\n","import type { PrismaClient } from '@prisma/client'\nimport { StorageAdapterArgs } from '@/types'\nimport type { RequestHandler } from '@/types'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { runRegexp } from '@/lib/runs/runRegexp'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { stepsRegexp } from '@/lib/steps/stepsRegexp'\nimport { threads } from './threads'\nimport { messages } from './threads/messages'\nimport { runs } from './threads/runs'\nimport { run } from './threads/run'\nimport { steps } from './threads/runs/steps'\nimport { submitToolOutputs } from './threads/runs/submitToolOutputs'\nimport { assistants } from './assistants'\n\ntype MethodHandlers = { get?: RequestHandler; post?: RequestHandler }\n\nexport const prismaStorageAdapter = ({\n prisma,\n}: {\n prisma: PrismaClient\n}): ((args: StorageAdapterArgs) => { requestHandlers: Record<string, MethodHandlers> }) =>\n({ runAdapter }: StorageAdapterArgs) => ({\n requestHandlers: {\n '^/(?:v1/\|openai/)?assistants$': assistants({ prisma }),\n '^/(?:v1\|/?openai)/threads$': threads({ prisma }),\n [messagesRegexp]: messages({ prisma }),\n [runsRegexp]: runs({ prisma, runAdapter }),\n [runRegexp]: run({ prisma, runAdapter }),\n [stepsRegexp]: steps({ prisma }),\n [submitToolOutputsRegexp]: submitToolOutputs({ prisma, runAdapter }),\n },\n})\n","import type { OpenAI } from 'openai'\n\nexport const serializeThread = ({\n conversation,\n}: {\n conversation: OpenAI.Conversations.Conversation\n}) => ({\n id: conversation.id,\n object: 'thread' as 'thread',\n created_at: conversation.created_at,\n metadata: conversation.metadata,\n // TODO\n tool_resources: null,\n})\n","import type OpenAI from 'openai'\nimport { serializeThread } from './serializeThread'\n\ntype ThreadCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Thread>\n}\n\nexport const post = ({\n client,\n addAnnotations = false,\n}: {\n client: OpenAI\n addAnnotations?: boolean\n}) => async (_urlString: string, options: RequestInit & { body?: string }): Promise<ThreadCreateResponse> => {\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n\n const messages = body.messages \|\| []\n const metadata = body.metadata \|\| {}\n\n const conversation = await client.conversations.create({\n metadata,\n items: messages.map((message: OpenAI.Beta.ThreadCreateParams.Message) => {\n const contentType = message.role === 'user' ? 'input_text' : 'output_text'\n\n // Convert content to array format\n let contentArray: any[]\n\n if (typeof message.content === 'string') {\n // String content - convert to array format\n const contentItem: any = {\n type: contentType,\n text: message.content,\n }\n if (addAnnotations) {\n contentItem.annotations = []\n }\n contentArray = [contentItem]\n } else if (Array.isArray(message.content)) {\n // Array content - map each part\n contentArray = message.content.map((part: any) => {\n if (typeof part === 'string') {\n const item: any = {\n type: contentType,\n text: part,\n }\n if (addAnnotations) {\n item.annotations = []\n }\n return item\n }\n if (part.type === 'text') {\n const item: any = {\n type: contentType,\n text: part.text,\n }\n if (addAnnotations) {\n item.annotations = []\n }\n return item\n }\n if (part.type === 'image_file') {\n return {\n type: 'input_image',\n file_id: part.image_file.file_id,\n detail: part.image_file.detail ?? 'auto',\n }\n }\n if (part.type === 'image_url') {\n return {\n type: 'input_image',\n image_url: part.image_url.url,\n detail: part.image_url.detail ?? 'auto',\n }\n }\n const item: any = {\n type: contentType,\n text: '',\n }\n if (addAnnotations) {\n item.annotations = []\n }\n return item\n })\n } else {\n const contentItem: any = {\n type: contentType,\n text: '',\n }\n if (addAnnotations) {\n contentItem.annotations = []\n }\n contentArray = [contentItem]\n }\n\n return {\n type: \"message\",\n role: message.role === 'user' ? 'user' : 'assistant',\n content: contentArray,\n }\n }),\n });\n\n return new Response(JSON.stringify(\n serializeThread({ conversation }),\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n}\n","import type { OpenAI } from 'openai'\nimport { post } from './post'\nimport type { RequestHandler } from '@/types'\n\nexport const threads = ({\n client,\n addAnnotations = false,\n}: {\n client: OpenAI\n addAnnotations?: boolean\n}): { post: RequestHandler } => ({\n post: post({ client, addAnnotations }),\n})\n","import type OpenAI from 'openai'\nimport dayjs from 'dayjs'\nimport { isArray } from 'radash'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\nimport { serializeItemAsMessage } from '@/lib/items/serializeItemAsMessage'\n\ntype MessageCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Messages.Message>\n}\n\nconst contentBlocksFromContent = ({\n content,\n addAnnotations = false,\n}: {\n content: string \| OpenAI.Beta.Threads.Messages.MessageContentPartParam[]\n addAnnotations?: boolean\n}) => {\n if (isArray(content)) {\n return content.map((item) => {\n if (item.type === 'text') {\n const textItem: any = {\n type: 'input_text' as 'input_text',\n text: item.text,\n }\n if (addAnnotations) {\n textItem.annotations = []\n }\n return textItem\n }\n\n if (item.type === 'image_file') {\n return {\n type: 'input_image' as 'input_image',\n file_id: item.image_file.file_id,\n detail: item.image_file.detail ?? 'auto',\n }\n }\n\n if (item.type === 'image_url') {\n return {\n type: 'input_image' as 'input_image',\n image_url: item.image_url.url,\n detail: item.image_url.detail ?? 'auto',\n }\n }\n\n const textItem: any = {\n type: 'input_text' as 'input_text',\n text: '',\n }\n if (addAnnotations) {\n textItem.annotations = []\n }\n return textItem\n })\n }\n\n const textItem: any = {\n type: 'input_text' as 'input_text',\n text: content ?? '',\n }\n if (addAnnotations) {\n textItem.annotations = []\n }\n return [textItem]\n}\n\nconst contentBlocksFromAttachments = ({\n attachments,\n}: {\n attachments: OpenAI.Beta.Threads.Messages.MessageCreateParams.Attachment[]\n}) => (\n attachments.map((attachment) => ({\n type: 'input_file' as const,\n file_id: attachment.file_id,\n }))\n)\n\nconst messageContentBlocks = ({\n content,\n attachments,\n addAnnotations = false,\n}: {\n content: string \| OpenAI.Beta.Threads.Messages.MessageContentPartParam[]\n attachments: OpenAI.Beta.Threads.Messages.MessageCreateParams.Attachment[]\n addAnnotations?: boolean\n}) => ([\n ...contentBlocksFromContent({ content, addAnnotations }),\n ...contentBlocksFromAttachments({ attachments }),\n])\nexport const post = ({\n runAdapter,\n createResponseItems,\n addAnnotations = false,\n}: {\n runAdapter: RunAdapterWithAssistant\n createResponseItems: OpenAI.Responses.ResponseInputItem[]\n addAnnotations?: boolean\n}) => async (urlString: string, options: RequestInit & { body?: string }): Promise<MessageCreateResponse> => {\n const url = new URL(urlString)\n\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp))!\n\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const { role, content, attachments = [] } = body\n\n const item: OpenAI.Responses.ResponseInputItem.Message = {\n type: \"message\" as const,\n role,\n content: messageContentBlocks({\n content,\n attachments,\n addAnnotations,\n }),\n }\n\n createResponseItems.push(item)\n\n // const items = await openai.conversations.items.create(\n // threadId,\n // {\n // items: [\n // ],\n // }\n // );\n //\n\n const openaiAssistant = await runAdapter.getOpenaiAssistant({ select: { id: true } })\n\n return new Response(JSON.stringify(\n serializeItemAsMessage({\n item,\n threadId,\n openaiAssistant,\n createdAt: dayjs().unix(),\n }),\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n}\n","import { uid } from 'radash'\nimport type OpenAI from 'openai'\n\ntype ItemType = OpenAI.Conversations.ConversationItem \| OpenAI.Responses.ResponseItem \| OpenAI.Responses.ResponseInputItem.Message\n\nconst serializeContent = ({\n item,\n}: {\n item: ItemType\n}): OpenAI.Beta.Threads.Messages.MessageContent[] => {\n if (item.type === 'message') {\n return item.content.map((contentBlock) => {\n if (contentBlock.type === 'input_text') {\n return {\n type: 'text' as const,\n text: {\n value: contentBlock.text,\n annotations: [],\n },\n }\n } else if (contentBlock.type === 'output_text') {\n return {\n type: 'text' as const,\n text: {\n value: contentBlock.text,\n annotations: [],\n },\n }\n } else if (contentBlock.type === 'input_image') {\n return {\n type: 'image_file' as const,\n image_file: {\n file_id: contentBlock.file_id,\n detail: 'auto',\n },\n }\n }\n\n return null\n }).filter(Boolean) as OpenAI.Beta.Threads.Messages.TextContentBlock[]\n } else if (item.type === 'image_generation_call') {\n if (!item.result) return []\n\n return [{\n type: 'image_url' as const,\n image_url: {\n // @ts-expect-error bad openai types\n url: `data:image/${item.output_format};base64,${item.result}`,\n detail: 'auto' as const,\n },\n }]\n } else {\n return []\n }\n}\n\nconst serializeAttachments = ({\n item,\n}: {\n item: ItemType\n}): OpenAI.Beta.Threads.Messages.Message['attachments'] => {\n if (item.type !== 'message') return []\n\n const inputFiles = item.content.filter((contentBlock) => (\n contentBlock.type === 'input_file' && contentBlock.file_id\n )) as OpenAI.Responses.ResponseInputFile[]\n\n return inputFiles.map((inputFile: OpenAI.Responses.ResponseInputFile) => ({\n file_id: inputFile.file_id!,\n }))\n}\n\nconst serializeMetadata = ({\n item,\n}: {\n item: ItemType\n}): OpenAI.Beta.Threads.Messages.Message['metadata'] => {\n if (item.type === 'image_generation_call') {\n return {\n item: JSON.stringify({\n ...item,\n result: 'truncated',\n }),\n }\n }\n\n return {\n item: JSON.stringify(item),\n }\n}\n // assign(message.metadata as Record<any, any> ?? {}, message.toolCalls ? { toolCalls: message.toolCalls } : {}),\n\nexport const serializeItemAsMessage = ({\n item,\n threadId,\n openaiAssistant,\n createdAt,\n runId = null,\n status = 'completed',\n}: {\n item: ItemType\n threadId: string\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n createdAt: number\n runId?: string \| null\n status?: 'completed' \| 'in_progress'\n}): OpenAI.Beta.Threads.Message => ({\n id: (item as any).id \|\| uid(24),\n object: 'thread.message' as const,\n created_at: createdAt,\n thread_id: threadId,\n completed_at: null,\n incomplete_at: null,\n incomplete_details: null,\n role: typeof (item as any).role === 'string' ? (item as any).role : 'assistant',\n content: serializeContent({ item }),\n assistant_id: (item as any).role === 'assistant' ? openaiAssistant.id : null,\n run_id: runId,\n attachments: serializeAttachments({ item }),\n status: typeof (item as any).status === 'string' ? (item as any).status : status,\n metadata: serializeMetadata({ item }),\n})\n","import type OpenAI from 'openai'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { assign } from 'radash'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\nimport { serializeItemAsMessage } from '@/lib/items/serializeItemAsMessage'\nimport { responseId } from '@/lib/items/responseId'\n\ntype MessageCreateResponse = Response & {\n json: () => Promise<ReturnType<OpenAI.Beta.Threads.Messages['create']>>\n}\n\nexport const get = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}) => async (urlString: string): Promise<MessageCreateResponse> => {\n const url = new URL(urlString)\n\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp))!\n\n const {\n limit,\n order,\n after,\n } = assign({\n limit: '20',\n order: 'desc',\n // after: null,\n }, Object.fromEntries(url.searchParams))\n\n const conversation = await client.conversations.retrieve(threadId)\n const sortOrder = order === 'asc' ? 'asc' : 'desc'\n\n const items = await client.conversations.items.list(threadId, {\n limit: parseInt(limit, 10),\n after,\n order: sortOrder,\n })\n\n const itemsWithRunIds = mapItemsWithRunIds({ conversation, items: items.data })\n const responseMap = await fetchResponsesForItems({\n client,\n items: itemsWithRunIds,\n })\n\n const timestampedItems = assignTimestamps({\n items: itemsWithRunIds,\n responseMap,\n sortOrder,\n conversationCreatedAt: conversation.created_at,\n })\n\n const openaiAssistant = await runAdapter.getOpenaiAssistant({ select: { id: true } })\n\n return new Response(JSON.stringify({\n data: timestampedItems.map(({ item, runId, assignedTimestamp }) => (\n serializeItemAsMessage({\n item,\n threadId,\n openaiAssistant,\n createdAt: assignedTimestamp,\n runId,\n })\n )),\n has_more: items.has_more,\n last_id: items.last_id,\n }), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n}\n\ntype ItemWithRunId = {\n item: OpenAI.Conversations.ConversationItem\n runId: string \| null\n}\n\ntype ItemWithAssignedTimestamp = ItemWithRunId & {\n timestamp: number \| null\n assignedTimestamp: number\n}\n\nconst mapItemsWithRunIds = ({\n conversation,\n items,\n}: {\n conversation: OpenAI.Conversations.Conversation\n items: OpenAI.Conversations.ConversationItem[]\n}): ItemWithRunId[] => (\n items.map((item) => ({\n item,\n runId: item.id ? responseId({\n conversation,\n itemId: item.id,\n }) : null,\n }))\n)\n\nconst fetchResponsesForItems = async ({\n client,\n items,\n}: {\n client: OpenAI\n items: ItemWithRunId[]\n}): Promise<Map<string, OpenAI.Responses.Response>> => {\n const responseIds = Array.from(new Set(\n items\n .map(({ runId }) => runId)\n .filter((id): id is string => Boolean(id)),\n ))\n\n const results = await Promise.allSettled(\n responseIds.map((id) => client.responses.retrieve(id)),\n )\n\n const map = new Map<string, OpenAI.Responses.Response>()\n results.forEach((result, index) => {\n if (result.status === 'fulfilled') {\n map.set(responseIds[index], result.value)\n }\n })\n\n return map\n}\n\n// Ensure timestamps follow the requested order even when some items lack response metadata.\nconst assignTimestamps = ({\n items,\n responseMap,\n sortOrder,\n conversationCreatedAt,\n}: {\n items: ItemWithRunId[]\n responseMap: Map<string, OpenAI.Responses.Response>\n sortOrder: 'asc' \| 'desc'\n conversationCreatedAt: number\n}): ItemWithAssignedTimestamp[] => {\n const itemsWithTimestamps = items.map((entry) => ({\n ...entry,\n timestamp: entry.runId ? responseMap.get(entry.runId)?.created_at ?? null : null,\n assignedTimestamp: 0,\n }))\n\n const fallbackTimestampForIndex = (index: number): number => (\n sortOrder === 'asc'\n ? conversationCreatedAt + index\n : conversationCreatedAt + (itemsWithTimestamps.length - index)\n )\n\n const findNextKnownTimestamp = (startIndex: number) => {\n for (let i = startIndex; i < itemsWithTimestamps.length; i += 1) {\n const candidate = itemsWithTimestamps[i]\n if (candidate.timestamp != null) {\n return { index: i, timestamp: candidate.timestamp }\n }\n }\n\n return null\n }\n\n if (sortOrder === 'asc') {\n let lastAssigned: number \| null = null\n\n itemsWithTimestamps.forEach((entry, index) => {\n let nextValue = entry.timestamp\n\n if (nextValue == null) {\n if (lastAssigned != null) {\n nextValue = lastAssigned + 1\n } else {\n const nextKnown = findNextKnownTimestamp(index + 1)\n if (nextKnown) {\n const gap = nextKnown.index - index\n nextValue = nextKnown.timestamp - gap\n } else {\n nextValue = fallbackTimestampForIndex(index)\n }\n }\n }\n\n if (lastAssigned != null && nextValue <= lastAssigned) {\n nextValue = lastAssigned + 1\n }\n\n entry.assignedTimestamp = nextValue\n lastAssigned = nextValue\n })\n } else {\n let lastAssigned: number \| null = null\n\n itemsWithTimestamps.forEach((entry, index) => {\n let nextValue = entry.timestamp\n\n if (nextValue == null) {\n if (lastAssigned != null) {\n nextValue = lastAssigned - 1\n } else {\n const nextKnown = findNextKnownTimestamp(index + 1)\n if (nextKnown) {\n const gap = nextKnown.index - index\n nextValue = nextKnown.timestamp + gap\n } else {\n nextValue = fallbackTimestampForIndex(index)\n }\n }\n }\n\n if (lastAssigned != null && nextValue >= lastAssigned) {\n nextValue = lastAssigned - 1\n }\n\n entry.assignedTimestamp = nextValue\n lastAssigned = nextValue\n })\n }\n\n return itemsWithTimestamps\n}\n","import type { OpenAI } from 'openai';\n\ntype ItemResponseEntry = { responseId: string; itemIds: string[] };\n\nexport function responseId({\n conversation,\n itemId,\n}: {\n conversation: OpenAI.Conversations.Conversation;\n itemId: string;\n}): string \| null {\n if (!conversation.metadata) return null\n\n const metadata = conversation.metadata as Record<string, any>;\n\n const keys = Object.keys(metadata)\n .map(k => {\n const m = /^responseItemsMap(\\d+)$/.exec(k);\n return m ? { key: k, idx: Number(m[1]) } : null;\n })\n .filter((x): x is { key: string; idx: number } => !!x)\n .sort((a, b) => a.idx - b.idx);\n\n // scan newest → oldest (reverse order), and inside a bucket scan last entry → first\n for (let i = keys.length - 1; i >= 0; i--) {\n const raw = metadata[keys[i].key];\n if (!raw \|\| raw === '[]') continue;\n\n let arr: ItemResponseEntry[] = [];\n try {\n arr = JSON.parse(raw) as ItemResponseEntry[];\n if (!Array.isArray(arr)) continue;\n } catch {\n continue; // skip bad/partial JSON\n }\n\n for (let j = arr.length - 1; j >= 0; j--) {\n const entry = arr[j];\n if (entry?.itemIds?.includes(itemId)) {\n return entry.responseId \|\| null;\n }\n }\n }\n\n return null;\n}\n","import type { OpenAI } from 'openai'\nimport { post } from './post'\nimport { get } from './get'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const messages = ({\n client,\n runAdapter,\n createResponseItems,\n addAnnotations = false,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n createResponseItems: OpenAI.Responses.ResponseInputItem[]\n addAnnotations?: boolean\n}): { post: RequestHandler; get: RequestHandler } => ({\n post: post({ runAdapter, createResponseItems, addAnnotations }),\n get: get({ client, runAdapter }),\n})\n","import type OpenAI from 'openai'\n\ntype MessageCreateResponse = Response & {\n json: () => Promise<ReturnType<OpenAI.Beta.Threads.Messages['create']>>\n}\n\nexport const get = () => async (urlString: string): Promise<MessageCreateResponse> => {\n return new Response(JSON.stringify({\n data: [],\n has_more: false,\n last_id: null,\n }), {\n status: 200,\n headers: { 'Content-Type': 'application/json' },\n })\n}\n","import type OpenAI from 'openai'\nimport { uid } from 'radash'\nimport dayjs from 'dayjs'\nimport { assign } from 'radash'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { serializeResponseAsRun } from '@/lib/responses/serializeResponseAsRun'\nimport { RunAdapterWithAssistant } from '@/types'\nimport { saveResponseItemsToConversationMetadata } from '@/lib/responses/saveResponseItemsToConversationMetadata'\nimport { defaultAssistant, serializeTools, textConfig, truncation } from './shared'\n\ntype RunCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Run>\n}\n\nexport const post = ({\n client,\n runAdapter,\n createResponseItems,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n createResponseItems: OpenAI.Responses.ResponseInputItem[]\n}) => async (urlString: string, options: RequestInit & { body?: string }): Promise<RunCreateResponse> => {\n const url = new URL(urlString)\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp))!\n\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const {\n assistant_id,\n stream,\n } = body\n\n const openaiAssistant = await runAdapter.getOpenaiAssistant()\n\n const {\n model,\n instructions,\n // additional_instructions,\n tools,\n metadata,\n response_format,\n truncation_strategy,\n } = assign({\n ...defaultAssistant,\n ...openaiAssistant,\n }, body)\n\n const shouldSendInstructions = typeof instructions === 'string' &&\n instructions.trim().length > 0\n\n const responseBody: OpenAI.Responses.ResponseCreateParams = {\n conversation: threadId,\n stream,\n input: createResponseItems,\n }\n\n responseBody.model = model\n responseBody.metadata = metadata\n Object.assign(responseBody, serializeTools({ tools }))\n responseBody.truncation = truncation({ truncation_strategy })\n\n const normalizedText = textConfig({ response_format })\n if (normalizedText) {\n responseBody.text = normalizedText\n }\n\n if (shouldSendInstructions && typeof instructions === 'string') {\n responseBody.instructions = instructions\n }\n\n const response = await client.responses.create(responseBody)\n\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => (\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n ),\n })\n } catch (error: any) {\n console.error(error)\n\n const event = {\n event: 'thread.run.failed',\n data: {\n id: uid(24),\n failed_at: dayjs().unix(),\n last_error: {\n code: 'server_error',\n message: `${error?.message ?? ''} ${error?.cause?.message ?? ''}`,\n },\n },\n }\n\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n if (stream) {\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n const nonStreamResponse = response as OpenAI.Responses.Response\n const itemIds = (nonStreamResponse.output ?? [])\n .filter((o: OpenAI.Responses.ResponseOutputItem) => o.id)\n .map((o: OpenAI.Responses.ResponseOutputItem) => o.id!)\n\n if (itemIds.length > 0) {\n await saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId: nonStreamResponse.id,\n itemIds,\n })\n }\n\n const data = serializeResponseAsRun({\n response: nonStreamResponse,\n assistantId: assistant_id,\n })\n\n return new Response(JSON.stringify(\n data\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type OpenAI from 'openai'\n// @ts-ignore-next-line\nimport type { Run } from '@prisma/client'\n\nconst serializeStatus = ({\n response,\n}: {\n response: OpenAI.Responses.Response\n}): OpenAI.Beta.Threads.Run['status'] => {\n if (response.error) return 'failed'\n\n return (response.status?.toLowerCase() as 'completed' \| 'failed' \| 'in_progress' \| 'requires_action' \| undefined) ?? 'completed'\n}\n\nconst serializeUsage = ({\n response,\n}: {\n response: OpenAI.Responses.Response\n}) => ({\n prompt_tokens: response.usage?.input_tokens ?? 0,\n completion_tokens: response.usage?.output_tokens ?? 0,\n total_tokens: response.usage?.total_tokens ?? 0,\n})\n\nconst findPendingToolCalls = ({\n response,\n}: {\n response: OpenAI.Responses.Response\n}): OpenAI.Responses.ResponseFunctionToolCall[] => {\n const toolCalls = (response.output ?? []).filter(\n (item): item is OpenAI.Responses.ResponseFunctionToolCall => item.type === 'function_call',\n )\n\n if (toolCalls.length === 0) return []\n\n const completedCallIds = new Set(\n (response.output ?? [])\n .filter(\n (item) =>\n // @ts-expect-error missing openai type\n item.type === 'function_call_output',\n )\n .map((item) => (\n // @ts-expect-error missing openai type\n item.call_id\n ))\n .filter((id): id is string => Boolean(id)),\n )\n\n return toolCalls.filter((call) => !completedCallIds.has(call.call_id))\n}\n\nconst serializeToolCalls = ({\n toolCalls,\n}: {\n toolCalls: OpenAI.Responses.ResponseFunctionToolCall[]\n}) =>\n toolCalls.map((toolCall) => ({\n id: toolCall.call_id,\n type: 'function' as const,\n function: {\n name: toolCall.name,\n arguments: toolCall.arguments,\n },\n }))\n\nexport const serializeResponseAsRun = ({\n response,\n assistantId,\n}: {\n response: OpenAI.Responses.Response\n assistantId: string\n}): OpenAI.Beta.Threads.Run => {\n const pendingToolCalls = findPendingToolCalls({ response })\n const status = pendingToolCalls.length > 0 ? 'requires_action' : serializeStatus({ response })\n\n return {\n id: response.id,\n object: 'thread.run' as 'thread.run',\n created_at: response.created_at,\n thread_id: response.conversation!.id,\n assistant_id: assistantId,\n status,\n required_action:\n pendingToolCalls.length > 0\n ? {\n type: 'submit_tool_outputs',\n submit_tool_outputs: {\n tool_calls: serializeToolCalls({ toolCalls: pendingToolCalls }),\n },\n }\n : null,\n last_error: response.error as OpenAI.Beta.Threads.Run['last_error'],\n expires_at: response.created_at,\n started_at: response.created_at,\n cancelled_at: null,\n failed_at: response.error ? response.created_at : null,\n completed_at: status === 'completed' ? response.created_at : null,\n model: response.model,\n instructions: '',\n tools: [] as OpenAI.Beta.Threads.Run['tools'],\n metadata: response.metadata,\n usage: serializeUsage({ response }),\n truncation_strategy: {\n type: 'auto',\n },\n response_format: {\n type: 'text',\n },\n incomplete_details: null,\n max_completion_tokens: null,\n max_prompt_tokens: null,\n tool_choice: 'auto',\n parallel_tool_calls: true,\n }\n}\n","import type OpenAI from 'openai'\n\n/* ======================= responseItemsMap helpers ======================= /\n\ntype ItemResponseEntry = { responseId: string; itemIds: string[] }\ntype ConversationMetadata = Record<string, string>\n\nconst BUCKET_PREFIX = 'responseItemsMap' // keys: responseItemsMap0..15\nconst MAX_BUCKETS = 16 // OpenAI metadata key limit\nconst MAX_VALUE_LENGTH = 512 // OpenAI metadata value limit\n\nfunction parseBucket({ value }: { value?: string }): ItemResponseEntry[] {\n if (!value \|\| value === '[]') return []\n try {\n const arr = JSON.parse(value)\n return Array.isArray(arr) ? (arr as ItemResponseEntry[]) : []\n } catch {\n return []\n }\n}\n\nfunction serializeBucket({ entries }: { entries: ItemResponseEntry[] }): string {\n return JSON.stringify(entries)\n}\n\nfunction bucketKey({ index }: { index: number }): string {\n return `${BUCKET_PREFIX}${index}`\n}\n\nfunction listBucketIndices({ metadata }: { metadata: ConversationMetadata }): number[] {\n return Object.keys(metadata)\n .map((k) => {\n const m = new RegExp(`^${BUCKET_PREFIX}(\\\\d+)$`).exec(k)\n return m ? Number(m[1]) : -1\n })\n .filter((i) => i >= 0)\n .sort((a, b) => a - b)\n}\n\n// Flatten to FIFO (oldest → newest) list of pairs\ntype Pair = { responseId: string; itemId: string }\n\nfunction parseAllPairs({ metadata }: { metadata: ConversationMetadata }): Pair[] {\n const indices = listBucketIndices({ metadata })\n const pairs: Pair[] = []\n for (const idx of indices) {\n const key = bucketKey({ index: idx })\n const entries = parseBucket({ value: metadata[key] })\n for (const e of entries) {\n for (const iid of e.itemIds) {\n pairs.push({ responseId: e.responseId, itemId: iid })\n }\n }\n }\n return pairs\n}\n\nfunction serializeNonBucketEntries({ entries }: { entries: Array<[string, string]> }): ConversationMetadata {\n const result: ConversationMetadata = {}\n for (const [key, value] of entries) {\n result[key] = value\n }\n return result\n}\n\nfunction packIntoBuckets({ pairs, slots }: { pairs: Pair[]; slots: number }): string[] \| undefined {\n const buckets: string[] = []\n let currentEntries: ItemResponseEntry[] = []\n\n const flush = () => {\n if (currentEntries.length === 0) return true\n const serialized = serializeBucket({ entries: currentEntries })\n if (serialized.length > MAX_VALUE_LENGTH) return false\n if (buckets.length >= slots) return false\n buckets.push(serialized)\n currentEntries = []\n return true\n }\n\n for (const { responseId, itemId } of pairs) {\n const candidateEntries = currentEntries.map((entry) => ({\n responseId: entry.responseId,\n itemIds: [...entry.itemIds],\n }))\n const last = candidateEntries.at(-1)\n if (last && last.responseId === responseId) {\n last.itemIds.push(itemId)\n } else {\n candidateEntries.push({ responseId, itemIds: [itemId] })\n }\n\n const serialized = serializeBucket({ entries: candidateEntries })\n if (serialized.length <= MAX_VALUE_LENGTH) {\n currentEntries = candidateEntries\n continue\n }\n\n if (!flush()) return undefined\n\n currentEntries = [{ responseId, itemIds: [itemId] }]\n if (serializeBucket({ entries: currentEntries }).length > MAX_VALUE_LENGTH) {\n return undefined\n }\n }\n\n if (!flush()) return undefined\n\n return buckets\n}\n\nfunction metadataEquals(a: ConversationMetadata, b: ConversationMetadata): boolean {\n const keysA = Object.keys(a)\n const keysB = Object.keys(b)\n if (keysA.length !== keysB.length) return false\n for (const key of keysA) {\n if (!Object.prototype.hasOwnProperty.call(b, key)) return false\n if (a[key] !== b[key]) return false\n }\n return true\n}\n\nexport function appendItemIdsToConversationMetadata({\n metadata,\n responseId,\n itemIds,\n}: {\n metadata?: ConversationMetadata\n responseId: string\n itemIds: string[]\n}): { metadata: ConversationMetadata; changed: boolean } {\n const base = { ...(metadata \|\| {}) }\n const nonBucketEntries = Object.entries(base).filter(([key]) => !key.startsWith(BUCKET_PREFIX))\n const availableSlots = Math.max(0, MAX_BUCKETS - nonBucketEntries.length)\n const preservedNonBucket = serializeNonBucketEntries({ entries: nonBucketEntries })\n\n if (availableSlots <= 0) {\n return { metadata: base, changed: false }\n }\n\n const existingPairs = parseAllPairs({ metadata: base })\n const incomingPairs: Pair[] = itemIds.map((id) => ({ responseId, itemId: id }))\n const combinedPairs: Pair[] = existingPairs.concat(incomingPairs)\n\n let retainedOldestFirst: Pair[] = []\n\n for (let idx = combinedPairs.length - 1; idx >= 0; idx -= 1) {\n const candidate = [combinedPairs[idx], ...retainedOldestFirst]\n const buckets = packIntoBuckets({ pairs: candidate, slots: availableSlots })\n if (buckets) {\n retainedOldestFirst = candidate\n }\n }\n\n const buckets = packIntoBuckets({ pairs: retainedOldestFirst, slots: availableSlots })\n if (!buckets) {\n const changed = !metadataEquals(base, preservedNonBucket)\n return { metadata: changed ? preservedNonBucket : base, changed }\n }\n\n const rebuilt = { ...preservedNonBucket }\n buckets.forEach((value, index) => {\n if (value && value !== '[]') {\n rebuilt[bucketKey({ index })] = value\n }\n })\n\n const changed = !metadataEquals(base, rebuilt)\n return { metadata: rebuilt, changed }\n}\n\nexport async function saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId,\n itemIds,\n}: {\n client: OpenAI\n threadId: string\n responseId: string\n itemIds: string[]\n}) {\n const conversation = await client.conversations.retrieve(threadId)\n const { metadata: updated, changed } = appendItemIdsToConversationMetadata({\n metadata: conversation.metadata as Record<string, string> \| undefined,\n responseId,\n itemIds,\n })\n if (!changed) return\n await client.conversations.update(threadId, { metadata: updated })\n}\n","import type OpenAI from 'openai'\n\nexport const serializeTools = ({\n tools,\n}: {\n tools: OpenAI.Beta.Threads.Runs.RunCreateParams['tools']\n}) => {\n if (!tools?.length) return {}\n\n return {\n tools: tools.map((tool) => ({\n type: tool.type,\n // @ts-ignore-next-line\n ...(tool[tool.type] \|\| {}),\n }))\n }\n}\n\nexport const truncation = ({\n truncation_strategy,\n}: {\n truncation_strategy: OpenAI.Beta.Threads.Runs.RunCreateParams['truncation_strategy']\n}) => {\n // @ts-expect-error compat\n if (truncation_strategy.type === 'disabled') {\n return 'disabled'\n }\n\n return 'auto'\n}\n\nexport const textConfig = ({\n response_format,\n}: {\n response_format: OpenAI.Beta.Threads.Runs.RunCreateParams['response_format']\n}): OpenAI.Responses.ResponseTextConfig \| undefined => {\n if (response_format && typeof response_format === 'object') {\n return {\n format: response_format as OpenAI.Responses.ResponseFormatTextConfig,\n }\n }\n return undefined\n}\n\nexport const defaultAssistant = {\n model: '',\n instructions: '',\n additional_instructions: null,\n truncation_strategy: {\n type: 'auto',\n },\n response_format: {\n type: 'text',\n },\n // tools: [],\n // metadata: {},\n}\n","import type { OpenAI } from 'openai'\nimport { get } from './get'\nimport { post } from './post'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const runs = ({\n client,\n runAdapter,\n createResponseItems,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n createResponseItems: OpenAI.Responses.ResponseInputItem[]\n}): { get: RequestHandler; post: RequestHandler } => ({\n get: get(),\n post: post({ client, createResponseItems, runAdapter }),\n})\n","import type OpenAI from 'openai'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { runRegexp } from '@/lib/runs/runRegexp'\nimport { serializeResponseAsRun } from '@/lib/responses/serializeResponseAsRun'\n\ntype GetResponse = Response & {\n json: () => Promise<ReturnType<OpenAI.Beta.Threads.Runs['retrieve']>>\n}\n\nexport const get = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}) => async (urlString: string): Promise<GetResponse> => {\n const url = new URL(urlString)\n\n const [, _threadId, runId] = url.pathname.match(new RegExp(runRegexp))!\n\n const response = await client.responses.retrieve(runId)\n\n const data = serializeResponseAsRun({\n response,\n assistantId: (await runAdapter.getOpenaiAssistant({ select: { id: true } })).id,\n })\n\n return new Response(JSON.stringify(data), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n 'openai-poll-after-ms': '5000',\n },\n })\n}\n","import type { OpenAI } from 'openai'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\nimport { get } from './get'\n// import { post } from './post'\n\nexport const run = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}): { get: RequestHandler } => ({\n get: get({ client, runAdapter }),\n // post: post({ prisma, runAdapter }),\n})\n","import type { OpenAI } from 'openai'\nimport { last } from 'radash'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { stepsRegexp } from '@/lib/steps/stepsRegexp'\nimport { serializeItemAsMessageCreationRunStep } from '@/lib/items/serializeItemAsMessageCreationRunStep'\nimport { serializeItemAsFunctionCallRunStep } from '@/lib/items/serializeItemAsFunctionCallRunStep'\nimport { serializeItemAsImageGenerationRunStep } from '@/lib/items/serializeItemAsImageGenerationRunStep'\nimport { serializeItemAsWebSearchRunStep } from '@/lib/items/serializeItemAsWebSearchRunStep'\nimport { serializeItemAsMcpListToolsRunStep } from '@/lib/items/serializeItemAsMcpListToolsRunStep'\nimport { serializeItemAsMcpCallRunStep } from '@/lib/items/serializeItemAsMcpCallRunStep'\nimport { serializeItemAsCodeInterpreterCallRunStep } from '@/lib/items/serializeItemAsCodeInterpreterCallRunStep'\nimport { serializeItemAsComputerCallRunStep } from '@/lib/items/serializeItemAsComputerCallRunStep'\nimport { serializeItemAsReasoningRunStep } from '@/lib/items/serializeItemAsReasoningRunStep'\n\nexport const get = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}) => async (urlString: string) => {\n const url = new URL(urlString)\n\n const [, threadId, runId] = url.pathname.match(new RegExp(stepsRegexp))!\n\n // const {\n // limit,\n // order,\n // after,\n // } = assign({\n // limit: '20',\n // order: 'desc',\n // // after: null,\n // }, Object.fromEntries(url.searchParams))\n\n const response = await client.responses.retrieve(runId)\n\n const latestToolCallItem = response.output.findLast((item) => (\n item.type === 'function_call'\n // item.type === 'computer_call'\n ))\n\n let functionCallOutputItems: OpenAI.Responses.ResponseFunctionToolCallOutputItem[] = []\n let computerCallOutputItems: OpenAI.Responses.ResponseComputerToolCallOutputItem[] = []\n\n if (latestToolCallItem) {\n const items = await client.conversations.items.list(threadId, {\n after: latestToolCallItem.id,\n order: 'asc',\n limit: 20,\n })\n\n functionCallOutputItems = items.data.filter((item) => item.type === 'function_call_output') as OpenAI.Responses.ResponseFunctionToolCallOutputItem[]\n computerCallOutputItems = items.data.filter((item) => item.type === 'computer_call_output') as OpenAI.Responses.ResponseComputerToolCallOutputItem[]\n }\n\n const openaiAssistant = await runAdapter.getOpenaiAssistant({ select: { id: true } })\n\n const data = response.output.flatMap((item) => {\n const step = serializeItemAsMessageCreationRunStep({\n item: item as any,\n threadId,\n openaiAssistant,\n runId: response.id,\n });\n\n if (item.type === 'function_call') {\n return [\n serializeItemAsFunctionCallRunStep({\n item,\n items: functionCallOutputItems,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n } else if (item.type === 'computer_call') {\n return [\n serializeItemAsComputerCallRunStep({\n item,\n items: computerCallOutputItems,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n } else if (item.type === 'reasoning') {\n return [\n serializeItemAsReasoningRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n } else if (item.type === 'image_generation_call') {\n return [\n serializeItemAsImageGenerationRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n } else if (item.type === 'web_search_call') {\n return [\n serializeItemAsWebSearchRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n } else if (item.type === 'mcp_list_tools') {\n return [\n serializeItemAsMcpListToolsRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n } else if (item.type === 'mcp_call') {\n return [\n serializeItemAsMcpCallRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n } else if (item.type === 'code_interpreter_call') {\n return [\n serializeItemAsCodeInterpreterCallRunStep({\n item,\n openaiAssistant,\n threadId,\n runId: response.id,\n }),\n step,\n ]\n }\n\n return [step];\n })\n\n return new Response(JSON.stringify({\n data,\n has_more: false,\n last_id: last(response.output)?.id ?? null,\n }), {\n status: 200,\n headers: { 'Content-Type': 'application/json' },\n })\n}\n","import dayjs from 'dayjs'\nimport { uid } from 'radash'\nimport type OpenAI from 'openai'\n\ntype RunStep = OpenAI.Beta.Threads.Runs.RunStep\n\nexport function serializeItemAsMessageCreationRunStep({\n item,\n threadId,\n openaiAssistant,\n runId = `run_${uid(24)}`,\n status = 'completed',\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Conversations.ConversationItem \| OpenAI.Responses.ResponseItem \| OpenAI.Responses.ResponseFunctionToolCall\n threadId: string\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n runId?: string\n status?: 'completed' \| 'in_progress'\n completedAt?: number \| null\n}): RunStep {\n // Normalize the item id to a definite string\n const itemId: string = typeof item.id === 'string' ? item.id : `item_${uid(18)}`\n\n const base: Omit<RunStep, 'type' \| 'step_details'> = {\n id: itemId,\n object: 'thread.run.step',\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n }\n\n if (item.type === 'message') {\n return {\n ...base,\n type: 'message_creation',\n step_details: {\n type: 'message_creation',\n message_creation: {\n // If you also create a thread.message elsewhere, substitute that id here.\n message_id: itemId, // <- always string\n },\n },\n // keep role if present (assistant/user/system), optional\n metadata: 'role' in item ? { role: (item as any).role } : {},\n }\n } else if (item.type === 'image_generation_call') {\n return {\n ...base,\n type: 'message_creation',\n step_details: {\n type: 'message_creation',\n message_creation: { message_id: itemId },\n },\n metadata: {\n item: JSON.stringify({\n ...item,\n result: 'truncated',\n }),\n },\n }\n }\n\n return {\n ...base,\n type: 'message_creation',\n step_details: {\n type: 'message_creation',\n message_creation: { message_id: itemId },\n },\n metadata: {\n item: JSON.stringify(item),\n },\n }\n}\n","import dayjs from 'dayjs'\nimport { uid } from 'radash'\nimport type OpenAI from 'openai'\n\ntype RunStep = OpenAI.Beta.Threads.Runs.RunStep\ntype FunctionToolCall = OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall\ntype ToolCallsStepDetails = OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails\n\nconst serializeFunctionCallOutput = ({\n functionCallOutput,\n}: {\n functionCallOutput: OpenAI.Responses.ResponseFunctionToolCallOutputItem \| undefined\n}) => {\n if (!functionCallOutput) return null\n if (typeof functionCallOutput.output === 'string') {\n return functionCallOutput.output\n }\n\n return JSON.stringify(functionCallOutput.output)\n}\n\nexport const serializeItemAsFunctionCallRunStep = ({\n item,\n items,\n threadId,\n openaiAssistant,\n runId = `run_${uid(24)}`,\n status = 'completed',\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Responses.ResponseFunctionToolCall\n items: Omit<OpenAI.Responses.ResponseFunctionToolCallOutputItem, 'id'>[]\n threadId: string\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n runId?: string\n status?: 'completed' \| 'in_progress'\n completedAt?: number \| null\n}): RunStep => {\n // Normalize the item id to a definite string\n const itemId: string = typeof item.id === 'string' ? item.id : `item_${uid(18)}`\n\n const base: Omit<RunStep, 'type' \| 'step_details'> = {\n id: itemId,\n object: 'thread.run.step',\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n }\n\n const functionCallOutput = items.find((i) => (\n i.type === 'function_call_output' &&\n i.call_id === item.call_id\n )) as OpenAI.Responses.ResponseFunctionToolCallOutputItem \| undefined\n\n const toolCall: FunctionToolCall = {\n id: item.call_id,\n type: 'function',\n function: {\n name: item.name,\n arguments: item.arguments,\n output: serializeFunctionCallOutput({ functionCallOutput }),\n },\n }\n\n return {\n ...base,\n type: 'tool_calls',\n step_details: {\n type: 'tool_calls',\n tool_calls: [toolCall],\n } satisfies ToolCallsStepDetails,\n }\n}\n","import type { OpenAI } from 'openai'\nimport dayjs from 'dayjs'\n\nconst serializeStatus = ({\n item,\n}: {\n item: OpenAI.Responses.ResponseItem.ImageGenerationCall\n}) => {\n // OpenAI bug: status is 'generating' even when result is present\n if (item.result !== null) {\n return 'completed' as const\n }\n\n if (item.status === 'generating') {\n return 'in_progress' as const\n }\n\n return item.status\n}\n\nexport const serializeItemAsImageGenerationRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = dayjs().unix(),\n status = serializeStatus({ item }),\n}: {\n item: OpenAI.Responses.ResponseItem.ImageGenerationCall\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n threadId: string\n runId: string\n completedAt?: number \| null\n status?: 'completed' \| 'in_progress' \| 'failed'\n}) => {\n const toolCall: OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall = {\n id: `ftc${item.id}`,\n type: 'function' as const,\n function: {\n name: 'image_generation',\n arguments: '{}',\n output: JSON.stringify({\n status: item.status,\n // @ts-expect-error bad openai types\n background: item.background,\n // @ts-expect-error bad openai types\n output_format: item.output_format,\n // @ts-expect-error bad openai types\n quality: item.quality,\n result: item.result,\n // @ts-expect-error bad openai types\n size: item.size,\n // @ts-expect-error bad openai types\n revised_prompt: item.revised_prompt,\n })\n },\n }\n\n return {\n id: `fc${item.id}`,\n object: 'thread.run.step' as const,\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: 'tool_calls' as const,\n step_details: {\n type: 'tool_calls' as const,\n tool_calls: [toolCall],\n } satisfies OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails,\n }\n}\n","import type { OpenAI } from 'openai'\nimport dayjs from 'dayjs'\n\nconst serializeStatus = ({\n item,\n}: {\n item: OpenAI.Responses.ResponseFunctionWebSearch\n}) => {\n if (item.status === 'searching') {\n return 'in_progress' as const\n }\n\n return item.status\n}\n\nexport const serializeItemAsWebSearchRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Responses.ResponseFunctionWebSearch\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n threadId: string\n runId: string\n completedAt?: number \| null\n}) => {\n const toolCall: OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall = {\n id: `ftc${item.id}`,\n type: 'function' as const,\n function: {\n name: 'web_search',\n arguments: JSON.stringify({\n // @ts-expect-error bad openai types\n action: item.action,\n }),\n output: JSON.stringify({\n status: item.status,\n }),\n },\n }\n\n return {\n id: `fc${item.id}`,\n object: 'thread.run.step' as const,\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus({ item }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: 'tool_calls' as const,\n step_details: {\n type: 'tool_calls' as const,\n tool_calls: [toolCall],\n } satisfies OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails,\n }\n}\n","import type { OpenAI } from 'openai'\nimport dayjs from 'dayjs'\n\nconst serializeStatus = ({\n item,\n}: {\n item: OpenAI.Responses.ResponseItem.McpListTools\n}) => {\n if (item.error) {\n return 'failed' as const\n }\n\n return 'completed' as const\n}\n\nexport const serializeItemAsMcpListToolsRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Responses.ResponseItem.McpListTools\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n threadId: string\n runId: string\n completedAt?: number \| null\n}) => {\n const toolCall: OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall = {\n id: `ftc${item.id}`,\n type: 'function' as const,\n function: {\n name: 'mcp_list_tools',\n arguments: JSON.stringify({\n server_label: item.server_label,\n }),\n output: JSON.stringify({\n tools: item.tools,\n ...(item.error && { error: item.error }),\n }),\n },\n }\n\n return {\n id: `fc${item.id}`,\n object: 'thread.run.step' as const,\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus({ item }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: 'tool_calls' as const,\n step_details: {\n type: 'tool_calls' as const,\n tool_calls: [toolCall],\n } satisfies OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails,\n }\n}\n","import type { OpenAI } from 'openai'\nimport dayjs from 'dayjs'\n\nconst serializeStatus = ({\n item,\n}: {\n item: OpenAI.Responses.ResponseItem.McpCall\n}) => {\n if (item.error) {\n return 'failed' as const\n }\n\n return 'completed' as const\n}\n\nexport const serializeItemAsMcpCallRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Responses.ResponseItem.McpCall\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n threadId: string\n runId: string\n completedAt?: number \| null\n}) => {\n const toolCall: OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall = {\n id: `ftc${item.id}`,\n type: 'function' as const,\n function: {\n name: item.name,\n arguments: item.arguments,\n // @ts-expect-error compat\n server_label: item.server_label,\n output: item.output ?? item.error ?? null,\n },\n }\n\n return {\n id: `fc${item.id}`,\n object: 'thread.run.step' as const,\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus({ item }),\n last_error: item.error ? { code: 'server_error' as const, message: item.error } : null,\n expired_at: null,\n cancelled_at: null,\n failed_at: item.error ? dayjs().unix() : null,\n completed_at: item.error ? null : completedAt,\n metadata: {},\n usage: null,\n type: 'tool_calls' as const,\n step_details: {\n type: 'tool_calls' as const,\n tool_calls: [toolCall],\n } satisfies OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails,\n }\n}\n","import type { OpenAI } from 'openai'\nimport dayjs from 'dayjs'\n\nconst serializeStatus = ({\n item,\n}: {\n item: OpenAI.Responses.ResponseCodeInterpreterToolCall\n}) => {\n if (item.status === 'incomplete') {\n return 'in_progress' as const\n } else if (item.status === 'interpreting') {\n return 'in_progress' as const\n }\n\n return item.status\n}\n\nconst serializeOutput = ({\n output,\n}: {\n output: OpenAI.Responses.ResponseCodeInterpreterToolCall.Logs\n // \| OpenAI.Responses.ResponseCodeInterpreterToolCall.Image\n}) => {\n // if (output.type === 'logs') {\n return {\n type: output.type,\n logs: output.logs,\n }\n // }\n\n // if (output.type === 'image') {\n // return {\n // type: output.type,\n // image: {\n // url: output.url,\n // },\n // }\n // }\n}\n\nconst serializeOutputs = ({\n item,\n}: {\n item: OpenAI.Responses.ResponseCodeInterpreterToolCall\n}) => {\n if (!item.outputs) return []\n\n return (item.outputs.filter(o => o.type === 'logs') as OpenAI.Responses.ResponseCodeInterpreterToolCall.Logs[])\n .map((output) => serializeOutput({ output }))\n}\n\nexport const serializeItemAsCodeInterpreterCallRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Responses.ResponseCodeInterpreterToolCall\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n threadId: string\n runId: string\n completedAt?: number \| null\n}) => {\n const toolCall: OpenAI.Beta.Threads.Runs.Steps.CodeInterpreterToolCall = {\n id: `citc${item.id}`,\n type: 'code_interpreter' as const,\n code_interpreter: {\n input: item.code ?? '',\n outputs: serializeOutputs({ item }),\n },\n }\n\n return {\n id: `fc${item.id}`,\n object: 'thread.run.step' as const,\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus({ item }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {\n item: JSON.stringify(item),\n },\n usage: null,\n type: 'tool_calls' as const,\n step_details: {\n type: 'tool_calls' as const,\n tool_calls: [toolCall],\n } satisfies OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails,\n }\n}\n","import dayjs from 'dayjs'\nimport { uid } from 'radash'\nimport type OpenAI from 'openai'\n\ntype RunStep = OpenAI.Beta.Threads.Runs.RunStep\ntype FunctionToolCall = OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall\ntype ToolCallsStepDetails = OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails\n\nexport const serializeItemAsComputerCallRunStep = ({\n item,\n items,\n threadId,\n openaiAssistant,\n runId = `run_${uid(24)}`,\n status = 'completed',\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Responses.ResponseComputerToolCall\n items: Omit<OpenAI.Responses.ResponseComputerToolCallOutputItem, 'id'>[]\n threadId: string\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n runId?: string\n status?: 'completed' \| 'in_progress'\n completedAt?: number \| null\n}): RunStep => {\n // Normalize the item id to a definite string\n const itemId: string = typeof item.id === 'string' ? item.id : `item_${uid(18)}`\n\n const base: Omit<RunStep, 'type' \| 'step_details'> = {\n id: itemId,\n object: 'thread.run.step',\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status,\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n }\n\n const computerCallOutput = items.find((i) => (\n i.type === 'computer_call_output' &&\n i.call_id === item.call_id\n )) as OpenAI.Responses.ResponseComputerToolCallOutputItem \| undefined\n\n const toolCall: FunctionToolCall = {\n id: item.call_id,\n type: 'function',\n function: {\n name: 'computer_call',\n arguments: JSON.stringify({\n action: item.action,\n pending_safety_checks: item.pending_safety_checks,\n }),\n output: computerCallOutput ? JSON.stringify(computerCallOutput.output) : null,\n },\n }\n\n return {\n ...base,\n type: 'tool_calls',\n step_details: {\n type: 'tool_calls',\n tool_calls: [toolCall],\n } satisfies ToolCallsStepDetails,\n }\n}\n","import type { OpenAI } from 'openai'\nimport dayjs from 'dayjs'\n\nconst serializeStatus = ({\n item,\n completedAt,\n}: {\n item: OpenAI.Responses.ResponseReasoningItem\n completedAt: number \| null\n}) => {\n if (!item.status) {\n if (completedAt) {\n return 'completed' as const\n } else {\n return 'in_progress' as const\n }\n }\n\n if (item.status === 'incomplete') {\n return 'in_progress' as const\n }\n\n return item.status\n}\n\nexport const serializeItemAsReasoningRunStep = ({\n item,\n openaiAssistant,\n threadId,\n runId,\n completedAt = dayjs().unix(),\n}: {\n item: OpenAI.Responses.ResponseReasoningItem\n openaiAssistant: Pick<OpenAI.Beta.Assistants.Assistant, 'id'>\n threadId: string\n runId: string\n completedAt?: number \| null\n}) => {\n const toolCall: OpenAI.Beta.Threads.Runs.Steps.FunctionToolCall = {\n id: `ftc${item.id}`,\n type: 'function' as const,\n function: {\n name: 'reasoning',\n arguments: '{}',\n output: JSON.stringify({\n summary: item.summary,\n content: item.content,\n encrypted_content: item.encrypted_content,\n }),\n },\n }\n\n return {\n id: `fc${item.id}`,\n object: 'thread.run.step' as const,\n created_at: dayjs().unix(),\n assistant_id: openaiAssistant.id,\n thread_id: threadId,\n run_id: runId,\n status: serializeStatus({ item, completedAt }),\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: completedAt,\n metadata: {},\n usage: null,\n type: 'tool_calls' as const,\n step_details: {\n type: 'tool_calls' as const,\n tool_calls: [toolCall],\n } satisfies OpenAI.Beta.Threads.Runs.Steps.ToolCallsStepDetails,\n }\n}\n","import type { OpenAI } from 'openai'\nimport { get } from './get'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const steps = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}): { get: RequestHandler } => ({\n get: get({ client, runAdapter }),\n})\n","import type { OpenAI } from 'openai'\n\nconst computerCallOutput = ({\n toolOutput,\n}: {\n toolOutput: OpenAI.Beta.Threads.RunSubmitToolOutputsParams['tool_outputs'][number]\n}) => {\n if (typeof toolOutput.output !== 'string') return { isComputerCallOutput: false }\n\n let parsedOutput\n\n try {\n parsedOutput = JSON.parse(toolOutput.output)\n } catch {\n return { isComputerCallOutput: false }\n }\n\n if (typeof parsedOutput !== 'object' \|\| parsedOutput === null) return { isComputerCallOutput: false }\n if (parsedOutput.type !== 'computer_screenshot') return { isComputerCallOutput: false }\n\n return {\n isComputerCallOutput: true,\n parsedOutput,\n }\n}\n\nexport const getToolCallOutputItems = ({\n tool_outputs,\n}: {\n tool_outputs: OpenAI.Beta.Threads.RunSubmitToolOutputsParams['tool_outputs']\n}) => {\n const functionCallOutputItems: Omit<OpenAI.Responses.ResponseFunctionToolCallOutputItem, 'id'>[] = []\n const computerCallOutputItems: Omit<OpenAI.Responses.ResponseComputerToolCallOutputItem, 'id'>[] = []\n\n tool_outputs.forEach((toolOutput) => {\n const { isComputerCallOutput, parsedOutput } = computerCallOutput({ toolOutput })\n\n if (isComputerCallOutput) {\n computerCallOutputItems.push({\n type: 'computer_call_output' as const,\n call_id: toolOutput.tool_call_id!,\n output: parsedOutput,\n // @ts-expect-error compat\n acknowledged_safety_checks: toolOutput.acknowledged_safety_checks ?? [],\n })\n } else {\n functionCallOutputItems.push({\n type: 'function_call_output' as const,\n call_id: toolOutput.tool_call_id!,\n output: toolOutput.output ?? '',\n })\n }\n })\n\n return {\n functionCallOutputItems,\n computerCallOutputItems,\n }\n}\n\nexport const serializeTools = ({\n tools,\n}: {\n tools: OpenAI.Beta.Threads.Runs.RunCreateParams['tools']\n}) => {\n if (!tools?.length) return {}\n\n return {\n tools: tools.map((tool) => ({\n type: tool.type,\n // @ts-ignore-next-line\n ...(tool[tool.type] \|\| {}),\n }))\n }\n}\n\nexport const truncation = ({\n openaiAssistant,\n}: {\n openaiAssistant: any\n}) => {\n if (openaiAssistant.truncation_strategy?.type === 'disabled') {\n return 'disabled'\n }\n\n return 'auto'\n}\n","import type { OpenAI } from 'openai'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { serializeItemAsFunctionCallRunStep } from '@/lib/items/serializeItemAsFunctionCallRunStep'\nimport { serializeItemAsComputerCallRunStep } from '@/lib/items/serializeItemAsComputerCallRunStep'\nimport { getToolCallOutputItems, serializeTools, truncation } from '../shared'\n\nexport const post = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}) => async (urlString: string, options: any) => {\n const url = new URL(urlString)\n const [, threadId, runId] = url.pathname.match(new RegExp(submitToolOutputsRegexp))!\n\n const body = JSON.parse(options.body)\n\n const {\n tool_outputs,\n stream,\n } = body\n\n const toolCallOutputItems = getToolCallOutputItems({ tool_outputs })\n const input = [...toolCallOutputItems.functionCallOutputItems, ...toolCallOutputItems.computerCallOutputItems]\n\n const previousResponse = await client.responses.retrieve(runId)\n\n const openaiAssistant = await runAdapter.getOpenaiAssistant()\n\n const shouldSendInstructions = typeof openaiAssistant.instructions === 'string' &&\n openaiAssistant.instructions.trim().length > 0\n\n const responseBody: OpenAI.Responses.ResponseCreateParams = {\n conversation: threadId,\n stream,\n input,\n }\n\n responseBody.model = openaiAssistant.model\n Object.assign(responseBody, serializeTools({ tools: openaiAssistant.tools }))\n responseBody.truncation = truncation({ openaiAssistant })\n\n if (shouldSendInstructions && typeof openaiAssistant.instructions === 'string') {\n responseBody.instructions = openaiAssistant.instructions\n }\n\n const response = await client.responses.create(responseBody)\n\n const readableStream = new ReadableStream({\n async start(controller) {\n toolCallOutputItems.functionCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => (\n i.type === 'function_call' &&\n i.call_id === item.call_id\n )) as OpenAI.Responses.ResponseFunctionToolCall \| undefined\n\n if (!toolCallItem) {\n return\n }\n\n controller.enqueue(`data: ${JSON.stringify({\n event: 'thread.run.step.completed',\n data: serializeItemAsFunctionCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.functionCallOutputItems,\n threadId,\n openaiAssistant,\n runId,\n })\n })}\\n\\n`)\n })\n\n toolCallOutputItems.computerCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => (\n i.type === 'computer_call' &&\n i.call_id === item.call_id\n )) as OpenAI.Responses.ResponseComputerToolCall \| undefined\n\n if (!toolCallItem) {\n return\n }\n\n controller.enqueue(`data: ${JSON.stringify({\n event: 'thread.run.step.completed',\n data: serializeItemAsComputerCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.computerCallOutputItems,\n threadId,\n openaiAssistant,\n runId,\n })\n })}\\n\\n`)\n })\n\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => (\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n ),\n })\n\n controller.close()\n },\n })\n\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n}\n","import type { OpenAI } from 'openai'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\nimport { post } from './post'\n\nexport const submitToolOutputs = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}): { post: RequestHandler } => ({\n post: post({\n client,\n runAdapter,\n }),\n})\n","import type { RunAdapterWithAssistant } from '@/types'\nimport type { OpenAI } from 'openai'\n\ntype ListResponse = Response & {\n json: () => Promise<ReturnType<OpenAI.Beta.Assistants['list']>>\n}\n\nexport const get = ({\n runAdapter,\n}: {\n runAdapter: RunAdapterWithAssistant\n}) => async (_urlString: string): Promise<ListResponse> => {\n return new Response(JSON.stringify({\n data: [await runAdapter.getOpenaiAssistant()],\n has_more: false,\n last_id: (await runAdapter.getOpenaiAssistant({ select: { id: true } })).id,\n }), {\n status: 200,\n headers: { 'Content-Type': 'application/json' },\n })\n}\n","export const post = () =>\n async () => (\n new Response(\n JSON.stringify({\n error: {\n message: 'Assistant creation is not implemented for the Responses storage adapter.',\n type: 'not_implemented',\n },\n }),\n {\n status: 501,\n headers: {\n 'Content-Type': 'application/json',\n },\n },\n )\n )\n","import { get } from './get'\nimport { post } from './post'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const assistants = ({\n runAdapter,\n}: {\n runAdapter: RunAdapterWithAssistant\n}): { get: RequestHandler, post: RequestHandler } => ({\n get: get({ runAdapter }),\n post: post(),\n})\n","import type { OpenAI } from 'openai'\nimport { StorageAdapterArgs, RunAdapterWithAssistant } from '@/types'\nimport type { RequestHandler } from '@/types'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { runRegexp } from '@/lib/runs/runRegexp'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { stepsRegexp } from '@/lib/steps/stepsRegexp'\nimport { threads } from './threads'\nimport { messages } from './threads/messages'\nimport { runs } from './threads/runs'\nimport { run } from './threads/run'\nimport { steps } from './threads/runs/steps'\nimport { submitToolOutputs } from './threads/runs/submitToolOutputs'\nimport { assistants } from './assistants'\n\ntype MethodHandlers = { get?: RequestHandler; post?: RequestHandler }\n\ntype ResponsesStorageAdapterArgs = StorageAdapterArgs & {\n runAdapter: RunAdapterWithAssistant\n}\n\nexport const responsesStorageAdapter = (): ((args: ResponsesStorageAdapterArgs) => { requestHandlers: Record<string, MethodHandlers> }) => {\n const createResponseItems: OpenAI.Responses.ResponseInputItem[] = []\n\n return ({ runAdapter, client }: ResponsesStorageAdapterArgs) => ({\n requestHandlers: {\n '^/(?:v1\|/?openai)/assistants$': assistants({ runAdapter }),\n '^/(?:v1\|/?openai)/threads$': threads({ client }),\n [messagesRegexp]: messages({ client, runAdapter, createResponseItems }),\n [runsRegexp]: runs({ client, runAdapter, createResponseItems }),\n [runRegexp]: run({ client, runAdapter }),\n [stepsRegexp]: steps({ client, runAdapter }),\n [submitToolOutputsRegexp]: submitToolOutputs({ client, runAdapter }),\n },\n })\n}\n","export const responseRegexp = '^/(?:v1\|/?openai)/responses/([^/]+)$'\n","import type OpenAI from 'openai'\nimport { uid } from 'radash'\nimport dayjs from 'dayjs'\nimport { assign } from 'radash'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { serializeResponseAsRun } from '@/lib/responses/serializeResponseAsRun'\nimport { RunAdapterWithAssistant } from '@/types'\nimport { saveResponseItemsToConversationMetadata } from '@/lib/responses/saveResponseItemsToConversationMetadata'\nimport { defaultAssistant, serializeTools, textConfig, truncation } from '@/adapters/storage/responsesStorageAdapter/threads/runs/shared'\n\ntype RunCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Run>\n}\n\nexport const post = ({\n client,\n runAdapter,\n createResponseItems,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n createResponseItems: OpenAI.Responses.ResponseInputItem[]\n}) => async (urlString: string, options: RequestInit & { body?: string }): Promise<RunCreateResponse> => {\n const url = new URL(urlString)\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp))!\n\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const {\n assistant_id,\n stream,\n } = body\n\n const assistantId = typeof assistant_id === 'string' ? assistant_id.trim() : ''\n const openaiAssistant = await runAdapter.getOpenaiAssistant()\n\n const {\n model,\n instructions,\n // additional_instructions,\n tools,\n metadata,\n response_format,\n truncation_strategy,\n } = assign({\n ...defaultAssistant,\n ...openaiAssistant,\n }, body)\n\n const azureAgentId = (\n openaiAssistant &&\n typeof openaiAssistant === 'object' &&\n typeof openaiAssistant.id === 'string' &&\n typeof openaiAssistant.name === 'string' &&\n openaiAssistant.id.trim().length > 0 &&\n openaiAssistant.id === openaiAssistant.name &&\n openaiAssistant.id === assistantId\n ) ? openaiAssistant.id : undefined\n const shouldSendInstructions = !azureAgentId &&\n typeof instructions === 'string' &&\n instructions.trim().length > 0\n\n const responseBody: OpenAI.Responses.ResponseCreateParams & {\n agent?: {\n name: string\n type: 'agent_reference'\n }\n } = {\n conversation: threadId,\n stream,\n input: createResponseItems,\n }\n\n if (azureAgentId) {\n responseBody.agent = {\n name: azureAgentId,\n type: 'agent_reference',\n }\n }\n\n if (!azureAgentId) {\n responseBody.model = model\n responseBody.metadata = metadata\n Object.assign(responseBody, serializeTools({ tools }))\n responseBody.truncation = truncation({ truncation_strategy })\n\n const normalizedText = textConfig({ response_format })\n if (normalizedText) {\n responseBody.text = normalizedText\n }\n } else if (metadata && Object.keys(metadata).length > 0) {\n responseBody.metadata = metadata\n }\n\n if (shouldSendInstructions && typeof instructions === 'string') {\n responseBody.instructions = instructions\n }\n\n const response = await client.responses.create(responseBody)\n\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => (\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n ),\n })\n } catch (error: any) {\n console.error(error)\n\n const event = {\n event: 'thread.run.failed',\n data: {\n id: uid(24),\n failed_at: dayjs().unix(),\n last_error: {\n code: 'server_error',\n message: `${error?.message ?? ''} ${error?.cause?.message ?? ''}`,\n },\n },\n }\n\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n if (stream) {\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n const nonStreamResponse = response as OpenAI.Responses.Response\n const itemIds = (nonStreamResponse.output ?? [])\n .filter((o: OpenAI.Responses.ResponseOutputItem) => o.id)\n .map((o: OpenAI.Responses.ResponseOutputItem) => o.id!)\n\n if (itemIds.length > 0) {\n await saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId: nonStreamResponse.id,\n itemIds,\n })\n }\n\n const data = serializeResponseAsRun({\n response: nonStreamResponse,\n assistantId: assistant_id,\n })\n\n return new Response(JSON.stringify(\n data\n ), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n}\n","import type { OpenAI } from 'openai'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\nimport { get } from '@/adapters/storage/responsesStorageAdapter/threads/runs/get'\nimport { post } from './post'\n\nexport const runs = ({\n client,\n runAdapter,\n createResponseItems,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n createResponseItems: OpenAI.Responses.ResponseInputItem[]\n}): { get: RequestHandler; post: RequestHandler } => ({\n get: get(),\n post: post({ client, createResponseItems, runAdapter }),\n})\n","import type { OpenAI } from 'openai'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { serializeItemAsFunctionCallRunStep } from '@/lib/items/serializeItemAsFunctionCallRunStep'\nimport { serializeItemAsComputerCallRunStep } from '@/lib/items/serializeItemAsComputerCallRunStep'\nimport { getToolCallOutputItems, serializeTools, truncation } from '@/adapters/storage/responsesStorageAdapter/threads/runs/submitToolOutputs/shared'\n\nexport const post = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}) => async (urlString: string, options: any) => {\n const url = new URL(urlString)\n const [, threadId, runId] = url.pathname.match(new RegExp(submitToolOutputsRegexp))!\n\n const body = JSON.parse(options.body)\n\n const {\n tool_outputs,\n stream,\n } = body\n\n const toolCallOutputItems = getToolCallOutputItems({ tool_outputs })\n const input = [...toolCallOutputItems.functionCallOutputItems, ...toolCallOutputItems.computerCallOutputItems]\n\n const previousResponse = await client.responses.retrieve(runId)\n\n const openaiAssistant = await runAdapter.getOpenaiAssistant()\n const azureAgentId = (\n openaiAssistant &&\n typeof openaiAssistant === 'object' &&\n typeof openaiAssistant.id === 'string' &&\n typeof openaiAssistant.name === 'string' &&\n openaiAssistant.id.trim().length > 0 &&\n openaiAssistant.id === openaiAssistant.name\n ) ? openaiAssistant.id : undefined\n\n const shouldSendInstructions = !azureAgentId &&\n typeof openaiAssistant.instructions === 'string' &&\n openaiAssistant.instructions.trim().length > 0\n\n const responseBody: OpenAI.Responses.ResponseCreateParams & {\n agent?: {\n name: string\n type: 'agent_reference'\n }\n } = {\n conversation: threadId,\n stream,\n input,\n }\n\n if (azureAgentId) {\n responseBody.agent = {\n name: azureAgentId,\n type: 'agent_reference',\n }\n }\n\n if (!azureAgentId) {\n responseBody.model = openaiAssistant.model\n Object.assign(responseBody, serializeTools({ tools: openaiAssistant.tools }))\n responseBody.truncation = truncation({ openaiAssistant })\n }\n\n if (shouldSendInstructions && typeof openaiAssistant.instructions === 'string') {\n responseBody.instructions = openaiAssistant.instructions\n }\n\n const response = await client.responses.create(responseBody)\n\n const readableStream = new ReadableStream({\n async start(controller) {\n toolCallOutputItems.functionCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => (\n i.type === 'function_call' &&\n i.call_id === item.call_id\n )) as OpenAI.Responses.ResponseFunctionToolCall \| undefined\n\n if (!toolCallItem) {\n return\n }\n\n controller.enqueue(`data: ${JSON.stringify({\n event: 'thread.run.step.completed',\n data: serializeItemAsFunctionCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.functionCallOutputItems,\n threadId,\n openaiAssistant,\n runId,\n })\n })}\\n\\n`)\n })\n\n toolCallOutputItems.computerCallOutputItems.forEach((item) => {\n const toolCallItem = previousResponse.output.find((i) => (\n i.type === 'computer_call' &&\n i.call_id === item.call_id\n )) as OpenAI.Responses.ResponseComputerToolCall \| undefined\n\n if (!toolCallItem) {\n return\n }\n\n controller.enqueue(`data: ${JSON.stringify({\n event: 'thread.run.step.completed',\n data: serializeItemAsComputerCallRunStep({\n item: toolCallItem,\n items: toolCallOutputItems.computerCallOutputItems,\n threadId,\n openaiAssistant,\n runId,\n })\n })}\\n\\n`)\n })\n\n await runAdapter.handleRun({\n threadId,\n response,\n onEvent: async (event) => (\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n ),\n })\n\n controller.close()\n },\n })\n\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n}\n","import type { OpenAI } from 'openai'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\nimport { post } from './post'\n\nexport const submitToolOutputs = ({\n client,\n runAdapter,\n}: {\n client: OpenAI\n runAdapter: RunAdapterWithAssistant\n}): { post: RequestHandler } => ({\n post: post({\n client,\n runAdapter,\n }),\n})\n","import type OpenAI from 'openai'\nimport { responseRegexp } from '@/lib/responses/responseRegexp'\n\ntype ResponseGetResponse = Response & {\n json: () => Promise<OpenAI.Responses.Response>\n}\n\nexport const get = ({\n client,\n}: {\n client: OpenAI\n}) => async (urlString: string): Promise<ResponseGetResponse> => {\n const url = new URL(urlString)\n const [, responseId] = url.pathname.match(new RegExp(responseRegexp))!\n\n // Call the Azure OpenAI client's responses.retrieve()\n // This client is obtained via AIProjectClient.getOpenAIClient()\n const response = await client.responses.retrieve(responseId)\n\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n}\n","import type OpenAI from 'openai'\nimport type { RequestHandler } from '@/types'\nimport { get } from './get'\n\nexport const responses = ({\n client,\n}: {\n client: OpenAI\n}): { get: RequestHandler } => ({\n get: get({ client }),\n})\n","import type { OpenAI } from 'openai'\nimport { StorageAdapterArgs, RunAdapterWithAssistant } from '@/types'\nimport type { RequestHandler } from '@/types'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { runRegexp } from '@/lib/runs/runRegexp'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { stepsRegexp } from '@/lib/steps/stepsRegexp'\nimport { responseRegexp } from '@/lib/responses/responseRegexp'\n// Reuse handlers from responsesStorageAdapter - they're already generic!\nimport { threads } from '../responsesStorageAdapter/threads'\nimport { messages } from '../responsesStorageAdapter/threads/messages'\nimport { runs } from './threads/runs'\nimport { run } from '../responsesStorageAdapter/threads/run'\nimport { steps } from '../responsesStorageAdapter/threads/runs/steps'\nimport { submitToolOutputs } from './threads/runs/submitToolOutputs'\nimport { assistants } from '../responsesStorageAdapter/assistants'\nimport { responses } from './responses'\n\ntype MethodHandlers = { get?: RequestHandler; post?: RequestHandler }\n\n\ntype AzureResponsesStorageAdapterArgs = StorageAdapterArgs & {\n runAdapter: RunAdapterWithAssistant\n originalClient?: any\n}\n\n/\n Storage adapter for Azure's Responses API (conversations + responses endpoints).\n \n Use this with Azure AI Projects and azureAiProjectClientAdapter:\n \n @example\n * ```typescript\n * const azureAiProject = new AIProjectClient(endpoint, credential)\n \n const client = supercompat({\n * client: azureAiProjectClientAdapter({ azureAiProject }),\n * storage: azureResponsesStorageAdapter(),\n * runAdapter: responsesRunAdapter({ getOpenaiAssistant: () => assistant }),\n * })\n * ```\n /\nexport const azureResponsesStorageAdapter = (): ((\n args: AzureResponsesStorageAdapterArgs,\n) => { requestHandlers: Record<string, MethodHandlers> }) => {\n const createResponseItems: OpenAI.Responses.ResponseInputItem[] = []\n let cachedClient: OpenAI \| null = null\n\n return ({ runAdapter, client, originalClient }: AzureResponsesStorageAdapterArgs) => {\n // Helper to get the AIProjectClient from the original client adapter\n const getAIProjectClient = (): any => {\n // If originalClient is provided and has a 'client' property, unwrap it\n if (originalClient && typeof originalClient === 'object' && 'client' in originalClient) {\n return (originalClient as any).client\n }\n // Fallback to client if originalClient not provided\n return client\n }\n\n // Helper to get Azure OpenAI client (with OAuth) from AIProjectClient\n const getAzureClient = async (): Promise<OpenAI> => {\n if (cachedClient) {\n return cachedClient\n }\n\n const aiProjectClient = getAIProjectClient()\n\n const apiVersion =\n typeof aiProjectClient === 'object'\n ? ((aiProjectClient as any)._options?.apiVersion as string \| undefined)\n : undefined\n\n // Check if it's an AIProjectClient (has getAzureOpenAIClient method)\n if (aiProjectClient && typeof aiProjectClient === 'object' && 'getAzureOpenAIClient' in aiProjectClient && typeof (aiProjectClient as any).getAzureOpenAIClient === 'function') {\n const azureClient = await (aiProjectClient as any).getAzureOpenAIClient(\n apiVersion ? { apiVersion } : undefined,\n )\n cachedClient = azureClient\n return azureClient\n }\n\n // Older AIProjectClient versions\n if (aiProjectClient && typeof aiProjectClient === 'object' && 'getOpenAIClient' in aiProjectClient && typeof (aiProjectClient as any).getOpenAIClient === 'function') {\n const azureClient = await (aiProjectClient as any).getOpenAIClient(\n apiVersion ? { apiVersion } : undefined,\n )\n cachedClient = azureClient\n return azureClient\n }\n\n // It's already an OpenAI client\n cachedClient = aiProjectClient\n return aiProjectClient\n }\n\n // Wrap runAdapter.handleRun to use Azure client instead of placeholder\n const wrappedRunAdapter: RunAdapterWithAssistant = {\n ...runAdapter,\n getOpenaiAssistant: runAdapter.getOpenaiAssistant,\n handleRun: async (args: any) => {\n const azureClient = await getAzureClient()\n return runAdapter.handleRun({ ...args, client: azureClient })\n },\n }\n\n // Helper to wrap a handler method with async OpenAI client retrieval\n const wrapHandlerMethod = (\n handlerFactory: (args: any) => any,\n method: 'get' \| 'post',\n ) => {\n return async (urlString: string, options: RequestInit) => {\n const openaiClient = await getAzureClient()\n const handler = handlerFactory({ client: openaiClient, runAdapter: wrappedRunAdapter, createResponseItems })\n return handler[method](urlString, options)\n }\n }\n\n // Create wrapped handlers for specified methods\n // Use the REAL Azure client so all API calls have proper authentication\n const createWrappedHandlers = (\n handlerFactory: (args: any) => any,\n methods: Array<'get' \| 'post'>,\n additionalArgs: any = {},\n ): MethodHandlers => {\n const wrapped: MethodHandlers = {}\n for (const method of methods) {\n wrapped[method] = async (urlString: string, options: RequestInit) => {\n // Use real Azure client so API calls are properly authenticated\n const azureClient = await getAzureClient()\n const handler = handlerFactory({\n client: azureClient, // Real Azure client with proper auth\n runAdapter: wrappedRunAdapter,\n createResponseItems,\n ...additionalArgs,\n })\n return handler[method](urlString, options)\n }\n }\n return wrapped\n }\n\n return {\n requestHandlers: {\n '^/(?:v1\|/?openai)/assistants$': assistants({ runAdapter: wrappedRunAdapter }),\n '^/(?:v1\|/?openai)/threads$': createWrappedHandlers(threads, ['post'], { addAnnotations: true }),\n [messagesRegexp]: createWrappedHandlers(messages, ['get', 'post']),\n [runsRegexp]: createWrappedHandlers(runs, ['get', 'post']), // Added GET for runs.list()\n [runRegexp]: createWrappedHandlers(run, ['get']),\n [stepsRegexp]: createWrappedHandlers(steps, ['get']),\n [submitToolOutputsRegexp]: createWrappedHandlers(submitToolOutputs, ['post']),\n [responseRegexp]: createWrappedHandlers(responses, ['get']),\n },\n }\n }\n}\n","import type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport dayjs from 'dayjs'\n\ntype ThreadCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Thread>\n}\n\nexport const post =\n ({ azureAiProject }: { azureAiProject: AIProjectClient }) =>\n async (\n _urlString: string,\n options: RequestInit & { body?: string },\n ): Promise<ThreadCreateResponse> => {\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const metadata = body.metadata \|\| {}\n\n const thread = await azureAiProject.agents.threads.create({\n metadata,\n })\n\n const openaiThread: OpenAI.Beta.Threads.Thread = {\n id: thread.id,\n object: 'thread',\n created_at: dayjs(thread.createdAt).unix(),\n metadata: thread.metadata \|\| {},\n tool_resources: null,\n }\n\n return new Response(JSON.stringify(openaiThread), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport { post } from './post'\nimport type { RequestHandler } from '@/types'\n\nexport const threads = ({\n azureAiProject,\n}: {\n azureAiProject: AIProjectClient\n}): { post: RequestHandler } => ({\n post: post({ azureAiProject }),\n})\n","import type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport dayjs from 'dayjs'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\n\ntype MessageCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Messages.Message>\n}\n\nexport const post =\n ({\n azureAiProject,\n runAdapter,\n }: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n }) =>\n async (\n urlString: string,\n options: RequestInit & { body?: string },\n ): Promise<MessageCreateResponse> => {\n const url = new URL(urlString)\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp))!\n\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const { role, content } = body\n\n // Extract text content\n let textContent = ''\n if (typeof content === 'string') {\n textContent = content\n } else if (Array.isArray(content)) {\n const textItem = content.find((item: any) => item.type === 'text')\n if (textItem) {\n textContent = textItem.text\n }\n }\n\n const message = await azureAiProject.agents.messages.create(\n threadId,\n role,\n textContent,\n )\n\n // Use assistantId and runId from the Azure message response\n // Azure docs show Message includes assistantId and runId fields\n const assistantId = (message as any).assistantId \|\| (message as any).assistant_id \|\| null\n const runId = (message as any).runId \|\| (message as any).run_id \|\| null\n\n const openaiMessage: OpenAI.Beta.Threads.Message = {\n id: message.id,\n object: 'thread.message',\n created_at: dayjs(message.createdAt).unix(),\n thread_id: message.threadId,\n role: message.role as 'user' \| 'assistant',\n content: message.content.map((c: any) => {\n if (c.type === 'text' && 'text' in c) {\n // Map annotations from Azure's camelCase to OpenAI's snake_case\n const annotations = (c.text.annotations \|\| []).map((ann: any) => {\n if (ann.type === 'file_citation') {\n return {\n type: 'file_citation' as const,\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_citation: {\n file_id: ann.fileCitation?.fileId \|\| ann.file_citation?.file_id,\n quote: ann.fileCitation?.quote \|\| ann.file_citation?.quote \|\| '',\n },\n }\n } else if (ann.type === 'file_path') {\n return {\n type: 'file_path' as const,\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_path: {\n file_id: ann.filePath?.fileId \|\| ann.file_path?.file_id,\n },\n }\n }\n return ann\n })\n\n return {\n type: 'text' as const,\n text: {\n value: c.text.value,\n annotations,\n },\n }\n } else if (c.type === 'image_file') {\n const imageFile = c.image_file \|\| c.imageFile \|\| {}\n return {\n type: 'image_file' as const,\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| '',\n detail: imageFile.detail ?? 'auto',\n },\n }\n }\n return c\n }),\n assistant_id: assistantId,\n run_id: runId,\n attachments: [],\n metadata: message.metadata \|\| {},\n status: 'completed',\n completed_at: dayjs(message.createdAt).unix(),\n incomplete_at: null,\n incomplete_details: null,\n }\n\n return new Response(JSON.stringify(openaiMessage), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport dayjs from 'dayjs'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\n\ntype MessageListResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Messages.MessagesPage>\n}\n\nexport const get =\n ({\n azureAiProject,\n runAdapter,\n }: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n }) =>\n async (urlString: string): Promise<MessageListResponse> => {\n const url = new URL(urlString)\n const [, threadId] = url.pathname.match(new RegExp(messagesRegexp))!\n\n const order = url.searchParams.get('order') \|\| 'desc'\n\n const messages = await azureAiProject.agents.messages.list(threadId, {\n order: order as 'asc' \| 'desc',\n })\n\n const messagesList: OpenAI.Beta.Threads.Message[] = []\n for await (const message of messages) {\n // Use assistantId and runId from the Azure message response\n // Azure docs show Message includes assistantId and runId fields\n const assistantId = (message as any).assistantId \|\| (message as any).assistant_id \|\| null\n const runId = (message as any).runId \|\| (message as any).run_id \|\| null\n\n messagesList.push({\n id: message.id,\n object: 'thread.message',\n created_at: dayjs(message.createdAt).unix(),\n thread_id: message.threadId,\n role: message.role as 'user' \| 'assistant',\n content: message.content.map((c: any) => {\n if (c.type === 'text' && 'text' in c) {\n // Map annotations from Azure's camelCase to OpenAI's snake_case\n const annotations = (c.text.annotations \|\| []).map((ann: any) => {\n if (ann.type === 'file_citation') {\n return {\n type: 'file_citation' as const,\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_citation: {\n file_id: ann.fileCitation?.fileId \|\| ann.file_citation?.file_id,\n quote: ann.fileCitation?.quote \|\| ann.file_citation?.quote \|\| '',\n },\n }\n } else if (ann.type === 'file_path') {\n return {\n type: 'file_path' as const,\n text: ann.text,\n start_index: ann.startIndex,\n end_index: ann.endIndex,\n file_path: {\n file_id: ann.filePath?.fileId \|\| ann.file_path?.file_id,\n },\n }\n }\n return ann\n })\n\n return {\n type: 'text' as const,\n text: {\n value: c.text.value,\n annotations,\n },\n }\n } else if (c.type === 'image_file') {\n const imageFile = c.image_file \|\| c.imageFile \|\| {}\n return {\n type: 'image_file' as const,\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| '',\n detail: imageFile.detail ?? 'auto',\n },\n }\n }\n return c\n }),\n assistant_id: assistantId,\n run_id: runId,\n attachments: [],\n metadata: message.metadata \|\| {},\n status: 'completed',\n completed_at: dayjs(message.createdAt).unix(),\n incomplete_at: null,\n incomplete_details: null,\n })\n }\n\n const response = {\n data: messagesList,\n first_id: messagesList[0]?.id \|\| null,\n last_id: messagesList[messagesList.length - 1]?.id \|\| null,\n has_more: false,\n }\n\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport { post } from './post'\nimport { get } from './get'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const messages = ({\n azureAiProject,\n runAdapter,\n}: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n}): { post: RequestHandler; get: RequestHandler } => ({\n post: post({ azureAiProject, runAdapter }),\n get: get({ azureAiProject, runAdapter }),\n})\n","import type OpenAI from 'openai'\n\ntype RunListResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Runs.RunsPage>\n}\n\nexport const get =\n () =>\n async (): Promise<RunListResponse> => {\n // Azure Agents doesn't provide a way to list runs\n // Return an empty list\n const response = {\n data: [],\n first_id: null,\n last_id: null,\n has_more: false,\n }\n\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport { uid } from 'radash'\nimport dayjs from 'dayjs'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { RunAdapterWithAssistant } from '@/types'\n\n// Get azureAgentId from the run adapter\ntype AzureAgentsRunAdapter = RunAdapterWithAssistant & {\n azureAgentId?: string\n}\n\ntype RunCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Run>\n}\n\nexport const post =\n ({\n azureAiProject,\n runAdapter,\n }: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n }) =>\n async (\n urlString: string,\n options: RequestInit & { body?: string },\n ): Promise<RunCreateResponse> => {\n const url = new URL(urlString)\n const [, threadId] = url.pathname.match(new RegExp(runsRegexp))!\n\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const { assistant_id, stream, instructions, tools } = body\n\n if (!assistant_id) {\n throw new Error('assistant_id is required')\n }\n\n // assistant_id from OpenAI API maps to azureAgentId\n const azureAgentId = assistant_id\n\n if (stream) {\n const readableStream = new ReadableStream({\n async start(controller) {\n try {\n await runAdapter.handleRun({\n threadId,\n assistantId: azureAgentId,\n instructions,\n tools,\n onEvent: async (event: any) => {\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n },\n } as any)\n } catch (error: any) {\n console.error(error)\n\n const event = {\n event: 'thread.run.failed',\n data: {\n id: uid(24),\n failed_at: dayjs().unix(),\n last_error: {\n code: 'server_error',\n message: `${error?.message ?? ''} ${error?.cause?.message ?? ''}`,\n },\n },\n }\n\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n }\n\n controller.close()\n },\n })\n\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n // For non-streaming, just create the run and return immediately\n // The OpenAI SDK will poll for status using runs.retrieve\n\n // Create the run in Azure (this starts it executing)\n // Retry with exponential backoff if thread already has active run\n let azureRun\n let retries = 0\n const maxRetries = 10\n\n while (retries < maxRetries) {\n try {\n // Build the options object for Azure run creation\n const createOptions: any = {}\n if (instructions) {\n createOptions.instructions = instructions\n }\n if (tools) {\n createOptions.tools = tools\n }\n\n azureRun = await azureAiProject.agents.runs.create(\n threadId,\n azureAgentId,\n createOptions,\n )\n break // Success, exit retry loop\n } catch (error: any) {\n const errorMessage = error?.message \|\| error?.cause?.message \|\| ''\n\n if (errorMessage.includes('already has an active run')) {\n // Extract the run ID from error message if possible\n const runIdMatch = errorMessage.match(/run_[a-zA-Z0-9]+/)\n\n if (runIdMatch) {\n const activeRunId = runIdMatch[0]\n // Wait for the active run to complete\n let activeRun = await azureAiProject.agents.runs.get(threadId, activeRunId)\n\n // Wait only if the run is actually in progress\n // requires_action is a terminal state that needs tool outputs to be submitted\n while (activeRun.status === 'queued' \|\| activeRun.status === 'in_progress') {\n await new Promise((resolve) => setTimeout(resolve, 500))\n activeRun = await azureAiProject.agents.runs.get(threadId, activeRunId)\n }\n\n // If the run is in requires_action state, we can't create a new run\n // We need to throw an error so the caller knows to handle it\n if (activeRun.status === 'requires_action') {\n throw new Error(`Thread ${threadId} has an active run ${activeRunId} that requires action (tool outputs must be submitted before creating a new run)`)\n }\n } else {\n // Can't determine run ID, just wait and retry\n await new Promise((resolve) => setTimeout(resolve, 1000 Math.pow(2, retries)))\n }\n\n retries++\n } else {\n // Different error, throw it\n throw error\n }\n }\n }\n\n if (!azureRun) {\n throw new Error(`Failed to create run after ${maxRetries} retries`)\n }\n\n // Return the run object immediately with its initial status\n const runData: OpenAI.Beta.Threads.Run = {\n id: azureRun.id,\n object: 'thread.run',\n created_at: dayjs(azureRun.createdAt).unix(),\n thread_id: azureRun.threadId,\n assistant_id: azureAgentId,\n status: azureRun.status as any,\n required_action: null,\n last_error: null,\n expires_at: null,\n started_at: azureRun.status === 'in_progress' ? dayjs(azureRun.createdAt).unix() : null,\n cancelled_at: null,\n failed_at: null,\n completed_at: null,\n incomplete_details: null,\n model: '',\n instructions: '',\n tools: [],\n metadata: azureRun.metadata \|\| {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: 'auto',\n last_messages: null,\n },\n response_format: 'auto',\n tool_choice: 'auto',\n parallel_tool_calls: true,\n usage: null,\n }\n\n return new Response(JSON.stringify(runData), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport { get } from './get'\nimport { post } from './post'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const runs = ({\n azureAiProject,\n runAdapter,\n}: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n}): { get: RequestHandler; post: RequestHandler } => ({\n get: get(),\n post: post({ azureAiProject, runAdapter }),\n})\n","import type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport dayjs from 'dayjs'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { runRegexp } from '@/lib/runs/runRegexp'\n\ntype RunGetResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Run>\n}\n\nexport const get =\n ({\n azureAiProject,\n runAdapter,\n }: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n }) =>\n async (urlString: string): Promise<RunGetResponse> => {\n const url = new URL(urlString)\n const [, threadId, runId] = url.pathname.match(new RegExp(runRegexp))!\n\n const azureRun = await azureAiProject.agents.runs.get(threadId, runId)\n\n // Get assistant ID from the Azure run\n const assistantId = azureRun.assistantId\n\n const openaiRun: OpenAI.Beta.Threads.Run = {\n id: azureRun.id,\n object: 'thread.run',\n created_at: dayjs(azureRun.createdAt).unix(),\n thread_id: azureRun.threadId,\n assistant_id: assistantId,\n status: azureRun.status as any,\n required_action:\n azureRun.status === 'requires_action' && azureRun.requiredAction\n ? {\n type: 'submit_tool_outputs',\n submit_tool_outputs: {\n tool_calls: (azureRun.requiredAction as any).submitToolOutputs.toolCalls.map(\n (tc: any) => ({\n id: tc.id,\n type: 'function' as const,\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments,\n },\n }),\n ),\n },\n }\n : null,\n last_error: azureRun.lastError\n ? {\n code: 'server_error',\n message: JSON.stringify(azureRun.lastError),\n }\n : null,\n expires_at: null,\n started_at: dayjs(azureRun.createdAt).unix(),\n cancelled_at: null,\n failed_at: azureRun.status === 'failed' ? dayjs().unix() : null,\n completed_at: azureRun.status === 'completed' ? dayjs().unix() : null,\n incomplete_details: null,\n model: '',\n instructions: '',\n tools: [],\n metadata: azureRun.metadata \|\| {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: 'auto',\n last_messages: null,\n },\n response_format: 'auto',\n tool_choice: 'auto',\n parallel_tool_calls: true,\n usage: null,\n }\n\n return new Response(JSON.stringify(openaiRun), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport { get } from './get'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const run = ({\n azureAiProject,\n runAdapter,\n}: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n}): { get: RequestHandler } => ({\n get: get({ azureAiProject, runAdapter }),\n})\n","import type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport type { PrismaClient } from '@prisma/client'\nimport dayjs from 'dayjs'\nimport type { RunAdapterWithAssistant } from '@/types'\nimport { stepsRegexp } from '@/lib/steps/stepsRegexp'\n\ntype StepListResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Runs.Steps.RunStepsPage>\n}\n\nexport const get =\n ({\n azureAiProject,\n runAdapter,\n prisma,\n }: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n prisma: PrismaClient\n }) =>\n async (urlString: string): Promise<StepListResponse> => {\n const url = new URL(urlString)\n const [, threadId, runId] = url.pathname.match(new RegExp(stepsRegexp))!\n\n const azureSteps = await azureAiProject.agents.runSteps.list(threadId, runId)\n\n // Retrieve all stored function outputs for this run in a single query\n const storedOutputs = await prisma.azureAgentsFunctionOutput.findMany({\n where: { runId },\n })\n\n // Create a lookup map for efficient retrieval: toolCallId -> output\n const outputsMap = new Map(\n storedOutputs.map((o) => [o.toolCallId, o.output])\n )\n\n const stepsList: OpenAI.Beta.Threads.Runs.RunStep[] = []\n for await (const step of azureSteps) {\n // Use assistantId from the Azure step response\n // Azure docs show RunStep includes assistantId field\n const assistantId = (step as any).assistantId \|\| (step as any).assistant_id \|\| ''\n\n stepsList.push({\n id: step.id,\n object: 'thread.run.step',\n created_at: dayjs(step.createdAt).unix(),\n assistant_id: assistantId,\n thread_id: threadId,\n run_id: runId,\n type: step.type === 'tool_calls' ? 'tool_calls' : 'message_creation',\n status: step.status as any,\n step_details:\n step.type === 'tool_calls'\n ? {\n type: 'tool_calls' as const,\n tool_calls: (step.stepDetails as any).toolCalls.map(\n (tc: any) => {\n if (tc.type === 'code_interpreter') {\n return {\n id: tc.id,\n type: 'code_interpreter' as const,\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| '',\n outputs: tc.codeInterpreter?.outputs?.map((output: any) => {\n if (output.type === 'logs') {\n return {\n type: 'logs' as const,\n logs: output.logs \|\| '',\n }\n }\n if (output.type === 'image') {\n return {\n type: 'image' as const,\n image: {\n file_id: output.image?.fileId \|\| '',\n },\n }\n }\n return output\n }) \|\| [],\n },\n }\n } else if (tc.type === 'file_search') {\n return {\n id: tc.id,\n type: 'file_search' as const,\n file_search: tc.fileSearch \|\| {},\n }\n } else if (tc.type === 'function') {\n return {\n id: tc.id,\n type: 'function' as const,\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments,\n // Retrieve output from database if Azure doesn't provide it\n // Use nullish coalescing (??) to preserve empty strings\n output: tc.function.output ?? outputsMap.get(tc.id) ?? null,\n },\n }\n }\n // Unknown tool type, return as-is\n return tc\n },\n ),\n }\n : {\n type: 'message_creation' as const,\n message_creation: {\n message_id: (step.stepDetails as any).messageCreation\n ?.messageId,\n },\n },\n last_error: null,\n expired_at: null,\n cancelled_at: null,\n failed_at: null,\n completed_at: step.completedAt ? dayjs(step.completedAt).unix() : null,\n metadata: step.metadata \|\| {},\n usage: null,\n })\n }\n\n const response = {\n data: stepsList,\n first_id: stepsList[0]?.id \|\| null,\n last_id: stepsList[stepsList.length - 1]?.id \|\| null,\n has_more: false,\n }\n\n return new Response(JSON.stringify(response), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport type { PrismaClient } from '@prisma/client'\nimport { get } from './get'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const steps = ({\n azureAiProject,\n runAdapter,\n prisma,\n}: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n prisma: PrismaClient\n}): { get: RequestHandler } => ({\n get: get({ azureAiProject, runAdapter, prisma }),\n})\n","import type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport type { PrismaClient } from '@prisma/client'\nimport { uid } from 'radash'\nimport dayjs from 'dayjs'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { RunAdapterWithAssistant } from '@/types'\n\n// Complete conversion function from run adapter\n// This handles ALL event types including thread.run.step.* events\nfunction convertAzureEventToOpenAI(\n azureEvent: any,\n assistantId: string,\n outputsMap: Map<string, string>,\n): OpenAI.Beta.AssistantStreamEvent \| null {\n const { event, data } = azureEvent\n const eventType = event as string\n\n // IMPORTANT: Exclude step events from the general run handler, they have their own handler below\n if (eventType.startsWith('thread.run.') && !eventType.startsWith('thread.run.step.')) {\n return {\n event: eventType as any,\n data: {\n id: data.id,\n object: 'thread.run',\n created_at: dayjs(data.createdAt).unix(),\n thread_id: data.threadId,\n assistant_id: assistantId,\n status: data.status,\n required_action: data.requiredAction\n ? {\n type: 'submit_tool_outputs',\n submit_tool_outputs: {\n tool_calls: (data.requiredAction as any).submitToolOutputs?.toolCalls?.map(\n (tc: any) => ({\n id: tc.id,\n type: 'function' as const,\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments,\n },\n }),\n ) \|\| [],\n },\n }\n : null,\n last_error: data.lastError\n ? {\n code: 'server_error',\n message: JSON.stringify(data.lastError),\n }\n : null,\n expires_at: null,\n started_at: data.startedAt ? dayjs(data.startedAt).unix() : null,\n cancelled_at: data.cancelledAt ? dayjs(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? dayjs(data.failedAt).unix() : null,\n completed_at: data.completedAt ? dayjs(data.completedAt).unix() : null,\n incomplete_details: null,\n model: data.model \|\| '',\n instructions: data.instructions \|\| '',\n tools: data.tools \|\| [],\n metadata: data.metadata \|\| {},\n temperature: data.temperature ?? null,\n top_p: data.topP ?? null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: 'auto',\n last_messages: null,\n },\n response_format: 'auto',\n tool_choice: 'auto',\n parallel_tool_calls: true,\n usage: null,\n } as OpenAI.Beta.Threads.Run,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType.startsWith('thread.message.') && eventType !== 'thread.message.delta') {\n return {\n event: eventType as any,\n data: {\n id: data.id,\n object: 'thread.message',\n created_at: dayjs(data.createdAt).unix(),\n thread_id: data.threadId,\n role: data.role,\n content: data.content?.map((c: any) => {\n if (c.type === 'text') {\n return {\n type: 'text',\n text: {\n value: c.text?.value \|\| '',\n annotations: c.text?.annotations \|\| [],\n },\n }\n }\n return c\n }) \|\| [],\n assistant_id: assistantId,\n run_id: data.runId \|\| null,\n attachments: data.attachments \|\| [],\n metadata: data.metadata \|\| {},\n status: data.status \|\| 'completed',\n completed_at: data.completedAt ? dayjs(data.completedAt).unix() : null,\n incomplete_at: null,\n incomplete_details: null,\n } as OpenAI.Beta.Threads.Message,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType === 'thread.message.delta') {\n return {\n event: 'thread.message.delta' as any,\n data: {\n id: data.id,\n object: 'thread.message.delta',\n delta: {\n content: data.delta?.content?.map((c: any) => {\n if (c.type === 'text') {\n return {\n index: c.index \|\| 0,\n type: 'text',\n text: {\n value: c.text?.value \|\| '',\n annotations: c.text?.annotations \|\| [],\n },\n }\n }\n return c\n }) \|\| [],\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType === 'thread.run.step.delta') {\n // Handle run step delta events separately - they have delta.stepDetails\n // Skip delta events where stepDetails is missing or has no type - these are incomplete\n if (!data.delta?.stepDetails \|\| !data.delta.stepDetails.type) {\n return null\n }\n\n let stepDetailsDelta: any = undefined\n\n if (data.delta?.stepDetails) {\n const details = data.delta.stepDetails\n if (details.type === 'tool_calls') {\n stepDetailsDelta = {\n type: 'tool_calls',\n tool_calls: details.toolCalls?.map((tc: any) => {\n if (tc.type === 'code_interpreter') {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: 'code_interpreter',\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| '',\n outputs: tc.codeInterpreter?.outputs?.map((output: any) => {\n if (output.type === 'logs') {\n return {\n index: output.index ?? 0,\n type: 'logs',\n logs: output.logs \|\| '',\n }\n }\n if (output.type === 'image') {\n return {\n index: output.index ?? 0,\n type: 'image',\n image: {\n file_id: output.image?.fileId \|\| '',\n },\n }\n }\n return output\n }) \|\| [],\n },\n }\n } else if (tc.type === 'file_search') {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: 'file_search',\n file_search: tc.fileSearch \|\| {},\n }\n } else if (tc.type === 'function') {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: 'function',\n function: {\n name: tc.function?.name \|\| '',\n arguments: tc.function?.arguments \|\| '',\n output: tc.function?.output ?? outputsMap.get(tc.id) ?? null,\n },\n }\n }\n return tc\n }) \|\| [],\n }\n } else {\n stepDetailsDelta = details\n }\n }\n\n // Final safety check: if stepDetailsDelta is still undefined after processing, skip this event\n if (stepDetailsDelta === undefined) {\n return null\n }\n\n return {\n event: 'thread.run.step.delta' as any,\n data: {\n id: data.id,\n object: 'thread.run.step.delta',\n delta: {\n step_details: stepDetailsDelta,\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType.startsWith('thread.run.step.')) {\n // Convert RunStep events with proper snake_case transformation\n // Skip events where stepDetails is missing, has no type, or where the step type is undefined\n // Azure sometimes sends incomplete step events during file_search initialization\n if (!data.stepDetails \|\| !data.stepDetails.type \|\| !data.type) {\n return null\n }\n\n let stepDetails: any = undefined\n\n if (data.stepDetails) {\n if (data.stepDetails.type === 'message_creation') {\n stepDetails = {\n type: 'message_creation',\n message_creation: {\n message_id: data.stepDetails.messageCreation?.messageId \|\| '',\n },\n }\n } else if (data.stepDetails.type === 'tool_calls') {\n stepDetails = {\n type: 'tool_calls',\n tool_calls: data.stepDetails.toolCalls?.map((tc: any) => {\n if (tc.type === 'code_interpreter') {\n return {\n id: tc.id,\n type: 'code_interpreter',\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| '',\n outputs: tc.codeInterpreter?.outputs?.map((output: any) => {\n if (output.type === 'logs') {\n return {\n type: 'logs',\n logs: output.logs \|\| '',\n }\n }\n if (output.type === 'image') {\n return {\n type: 'image',\n image: {\n file_id: output.image?.fileId \|\| '',\n },\n }\n }\n return output\n }) \|\| [],\n },\n }\n } else if (tc.type === 'file_search') {\n return {\n id: tc.id,\n type: 'file_search',\n file_search: tc.fileSearch \|\| {},\n }\n } else if (tc.type === 'function') {\n return {\n id: tc.id,\n type: 'function',\n function: {\n name: tc.function?.name \|\| '',\n arguments: tc.function?.arguments \|\| '',\n output: tc.function?.output ?? outputsMap.get(tc.id) ?? null,\n },\n }\n }\n return tc\n }) \|\| [],\n }\n } else {\n // Unknown type, pass through\n stepDetails = data.stepDetails\n }\n }\n\n // Final safety check: if stepDetails is still undefined after processing, skip this event\n // This prevents OpenAI SDK from crashing on incomplete events\n if (stepDetails === undefined) {\n return null\n }\n\n return {\n event: eventType as any,\n data: {\n id: data.id,\n object: 'thread.run.step',\n created_at: dayjs(data.createdAt).unix(),\n assistant_id: assistantId,\n thread_id: data.threadId,\n run_id: data.runId,\n type: data.type,\n status: data.status,\n step_details: stepDetails,\n last_error: data.lastError \|\| null,\n expired_at: null,\n cancelled_at: data.cancelledAt ? dayjs(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? dayjs(data.failedAt).unix() : null,\n completed_at: data.completedAt ? dayjs(data.completedAt).unix() : null,\n metadata: data.metadata \|\| {},\n usage: null,\n } as OpenAI.Beta.Threads.Runs.RunStep,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType === 'thread.created') {\n return {\n event: 'thread.created' as any,\n data: {\n id: data.id,\n object: 'thread',\n created_at: dayjs(data.createdAt).unix(),\n metadata: data.metadata \|\| {},\n tool_resources: data.toolResources \|\| null,\n } as OpenAI.Beta.Threads.Thread,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n // Return null for unhandled event types\n return null\n}\n\ntype SubmitToolOutputsResponse = Response & {\n json: () => Promise<OpenAI.Beta.Threads.Run>\n}\n\nexport const post =\n ({\n azureAiProject,\n runAdapter,\n prisma,\n }: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n prisma: PrismaClient\n }) =>\n async (\n urlString: string,\n options: RequestInit & { body?: string },\n ): Promise<SubmitToolOutputsResponse> => {\n const url = new URL(urlString)\n const [, threadId, runId] = url.pathname.match(\n new RegExp(submitToolOutputsRegexp),\n )!\n\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n const { tool_outputs, stream } = body\n\n // Create a map of tool outputs for efficient lookup during streaming\n const outputsMap = new Map(\n tool_outputs.map((output: { tool_call_id: string; output: string }) => [\n output.tool_call_id,\n output.output,\n ])\n ) as Map<string, string>\n\n // Store function tool outputs in database for later retrieval\n // since Azure API doesn't persist them\n await Promise.all(\n tool_outputs.map((output: { tool_call_id: string; output: string }) =>\n prisma.azureAgentsFunctionOutput.upsert({\n where: {\n runId_toolCallId: {\n runId,\n toolCallId: output.tool_call_id,\n },\n },\n create: {\n runId,\n toolCallId: output.tool_call_id,\n output: output.output,\n },\n update: {\n output: output.output,\n },\n })\n )\n )\n\n // Get the existing run to find the assistant_id (agent ID)\n const existingRun = await azureAiProject.agents.runs.get(threadId, runId)\n const assistantId = existingRun.assistantId\n\n // Submit tool outputs to Azure with streaming support\n const submitResponse = azureAiProject.agents.runs.submitToolOutputs(\n threadId,\n runId,\n tool_outputs.map((to: any) => ({\n toolCallId: to.tool_call_id,\n output: to.output,\n })),\n )\n\n // After submitting tool outputs, stream the results\n const streamRun = async (onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<void>) => {\n try {\n // Start streaming the results\n const stream = await submitResponse.stream()\n\n // Convert Azure events to OpenAI events and emit them\n for await (const azureEvent of stream) {\n const openaiEvent = convertAzureEventToOpenAI(azureEvent, assistantId, outputsMap)\n if (openaiEvent) {\n await onEvent(openaiEvent)\n }\n }\n } catch (error: any) {\n await onEvent({\n event: 'thread.run.failed',\n data: {\n id: runId,\n object: 'thread.run',\n created_at: dayjs().unix(),\n thread_id: threadId,\n assistant_id: assistantId,\n status: 'failed',\n required_action: null,\n last_error: {\n code: 'server_error',\n message: `${error?.message ?? ''} ${error?.cause?.message ?? ''}`,\n },\n expires_at: null,\n started_at: dayjs().unix(),\n cancelled_at: null,\n failed_at: dayjs().unix(),\n completed_at: null,\n incomplete_details: null,\n model: '',\n instructions: '',\n tools: [],\n metadata: {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: { type: 'auto', last_messages: null },\n response_format: 'auto',\n tool_choice: 'auto',\n parallel_tool_calls: true,\n usage: null,\n } as OpenAI.Beta.Threads.Run,\n })\n }\n }\n\n const readableStream = new ReadableStream({\n async start(controller) {\n await streamRun(async (event) => {\n controller.enqueue(`data: ${JSON.stringify(event)}\\n\\n`)\n })\n controller.close()\n },\n })\n\n if (stream) {\n return new Response(readableStream, {\n headers: {\n 'Content-Type': 'text/event-stream',\n },\n })\n } else {\n // For non-streaming, we need to collect all events\n const events: OpenAI.Beta.AssistantStreamEvent[] = []\n let finalRun: OpenAI.Beta.Threads.Run \| null = null\n\n await streamRun(async (event) => {\n events.push(event)\n if (\n event.event === 'thread.run.completed' \|\|\n event.event === 'thread.run.failed' \|\|\n event.event === 'thread.run.requires_action'\n ) {\n finalRun = event.data\n }\n })\n\n if (!finalRun) {\n throw new Error('Run did not complete')\n }\n\n return new Response(JSON.stringify(finalRun), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n }\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport type { PrismaClient } from '@prisma/client'\nimport { post } from './post'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const submitToolOutputs = ({\n azureAiProject,\n runAdapter,\n prisma,\n}: {\n azureAiProject: AIProjectClient\n runAdapter: RunAdapterWithAssistant\n prisma: PrismaClient\n}): { post: RequestHandler } => ({\n post: post({ azureAiProject, runAdapter, prisma }),\n})\n","import type OpenAI from 'openai'\nimport type { RunAdapterWithAssistant } from '@/types'\n\ntype AssistantCreateResponse = Response & {\n json: () => Promise<OpenAI.Beta.Assistants.Assistant>\n}\n\nexport const post =\n ({ runAdapter }: { runAdapter: RunAdapterWithAssistant }) =>\n async (\n _urlString: string,\n options: RequestInit & { body?: string },\n ): Promise<AssistantCreateResponse> => {\n // In Azure Agents, we don't actually create assistants - they're pre-configured in Azure\n // We just return a minimal assistant object with the ID that will be passed in subsequent calls\n // The assistant_id will be provided in the run creation requests\n\n if (typeof options.body !== 'string') {\n throw new Error('Request body is required')\n }\n\n const body = JSON.parse(options.body)\n\n // For Azure Agents, we don't create the assistant here\n // We just return a placeholder response since the actual agent is managed in Azure\n // The real assistant_id (Azure agent ID) will be provided when creating runs\n const openaiAssistant = {\n id: 'placeholder', // This will be overridden by the assistant_id passed to createRun\n object: 'assistant' as const,\n created_at: Math.floor(Date.now() / 1000),\n name: body.name \|\| null,\n description: body.description \|\| null,\n model: body.model,\n instructions: body.instructions \|\| null,\n tools: body.tools \|\| [],\n metadata: body.metadata \|\| {},\n top_p: body.top_p ?? null,\n temperature: body.temperature ?? null,\n response_format: body.response_format \|\| 'auto',\n }\n\n return new Response(JSON.stringify(openaiAssistant), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n }\n","import { post } from './post'\nimport type { RequestHandler, RunAdapterWithAssistant } from '@/types'\n\nexport const assistants = ({\n runAdapter,\n}: {\n runAdapter: RunAdapterWithAssistant\n}): { post: RequestHandler } => ({\n post: post({ runAdapter }),\n})\n","export const fileRegexp = '^/(?:v1\|/?openai)/files/([^/]+)$'\n","export const fileContentRegexp = '^/(?:v1\|/?openai)/files/([^/]+)/content$'\n","import dayjs from 'dayjs'\nimport type OpenAI from 'openai'\n\ntype AzureFileInfo = {\n id: string\n object?: string\n bytes?: number\n filename?: string\n createdAt?: Date \| number \| string\n purpose?: string\n status?: string\n statusDetails?: string\n expiresAt?: Date \| number \| string \| null\n}\n\nconst toUnixSeconds = (value?: Date \| number \| string \| null): number \| undefined => {\n if (!value) return undefined\n\n if (value instanceof Date) {\n return dayjs(value).unix()\n }\n\n if (typeof value === 'number') {\n // Azure sometimes returns seconds, sometimes milliseconds. Assume seconds when <= 10^11\n if (value > 9999999999) {\n return dayjs(value).unix()\n }\n return Math.floor(value)\n }\n\n const parsed = dayjs(value)\n return parsed.isValid() ? parsed.unix() : undefined\n}\n\nexport const transformAzureFile = (file: AzureFileInfo): OpenAI.Files.FileObject => {\n const createdAtUnix = toUnixSeconds(file.createdAt) ?? dayjs().unix()\n const expiresAtUnix = toUnixSeconds(file.expiresAt)\n\n const openaiFile: OpenAI.Files.FileObject = {\n id: file.id,\n object: (file.object \|\| 'file') as OpenAI.Files.FileObject['object'],\n bytes: file.bytes ?? 0,\n created_at: createdAtUnix,\n filename: file.filename \|\| 'file',\n purpose: (file.purpose \|\| 'assistants') as OpenAI.Files.FileObject['purpose'],\n status: (file.status \|\| 'processed') as OpenAI.Files.FileObject['status'],\n }\n\n if (expiresAtUnix !== undefined) {\n openaiFile.expires_at = expiresAtUnix\n }\n\n if (file.statusDetails) {\n openaiFile.status_details = file.statusDetails\n }\n\n return openaiFile\n}\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport { fileRegexp } from '@/lib/files/fileRegexp'\nimport type { RequestHandler } from '@/types'\nimport { transformAzureFile } from '@/lib/files/transformAzureFile'\n\nexport const file = ({\n azureAiProject,\n}: {\n azureAiProject: AIProjectClient\n}): { get: RequestHandler } => ({\n get: async (url) => {\n const { pathname } = new URL(url)\n const match = pathname.match(new RegExp(fileRegexp))\n\n if (!match) {\n return new Response('Not Found', { status: 404 })\n }\n\n const [, fileId] = match\n const azureFile = await azureAiProject.agents.files.get(fileId)\n const openaiFile = transformAzureFile(azureFile)\n\n return new Response(JSON.stringify(openaiFile), {\n status: 200,\n headers: {\n 'Content-Type': 'application/json',\n },\n })\n },\n})\n","import { Readable } from 'node:stream'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport { fileContentRegexp } from '@/lib/files/fileContentRegexp'\nimport type { RequestHandler } from '@/types'\n\nconst headersToRecord = (headers: any): Record<string, string> => {\n if (!headers) return {}\n\n if (typeof headers.get === 'function') {\n const result: Record<string, string> = {}\n for (const headerName of ['content-type', 'content-length']) {\n const value = headers.get(headerName)\n if (value) {\n result[headerName] = value\n }\n }\n return result\n }\n\n const json = typeof headers.toJSON === 'function' ? headers.toJSON() : headers\n return typeof json === 'object' && json !== null ? json : {}\n}\n\nconst toBody = async (nodeStream: NodeJS.ReadableStream) => {\n if (typeof (Readable as any).toWeb === 'function') {\n return Readable.toWeb(nodeStream as any) as unknown as BodyInit\n }\n\n const chunks: Buffer[] = []\n for await (const chunk of nodeStream) {\n chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))\n }\n return Buffer.concat(chunks)\n}\n\nexport const fileContent = ({\n azureAiProject,\n}: {\n azureAiProject: AIProjectClient\n}): { get: RequestHandler } => ({\n get: async (url) => {\n const { pathname } = new URL(url)\n const match = pathname.match(new RegExp(fileContentRegexp))\n\n if (!match) {\n return new Response('Not Found', { status: 404 })\n }\n\n const [, fileId] = match\n const streamable = azureAiProject.agents.files.getContent(fileId)\n\n if (!streamable \|\| typeof (streamable as any).asNodeStream !== 'function') {\n return new Response('File content unavailable', { status: 500 })\n }\n\n const nodeResponse = await (streamable as any).asNodeStream()\n const nodeStream = nodeResponse.body\n\n if (!nodeStream) {\n return new Response('', { status: 204 })\n }\n\n const headerRecord = headersToRecord(nodeResponse.headers)\n const headers = new Headers()\n\n for (const [key, value] of Object.entries(headerRecord)) {\n headers.set(key, value)\n }\n\n if (!headers.has('content-type')) {\n headers.set('Content-Type', 'application/octet-stream')\n }\n\n const body = await toBody(nodeStream)\n\n return new Response(body, {\n status: nodeResponse.status ?? 200,\n headers,\n })\n },\n})\n","import type { AIProjectClient } from '@azure/ai-projects'\nimport type { PrismaClient } from '@prisma/client'\nimport { StorageAdapterArgs, RunAdapterWithAssistant } from '@/types'\nimport type { RequestHandler } from '@/types'\nimport { messagesRegexp } from '@/lib/messages/messagesRegexp'\nimport { runsRegexp } from '@/lib/runs/runsRegexp'\nimport { runRegexp } from '@/lib/runs/runRegexp'\nimport { submitToolOutputsRegexp } from '@/lib/runs/submitToolOutputsRegexp'\nimport { stepsRegexp } from '@/lib/steps/stepsRegexp'\nimport { threads } from './threads'\nimport { messages } from './threads/messages'\nimport { runs } from './threads/runs'\nimport { run } from './threads/run'\nimport { steps } from './threads/runs/steps'\nimport { submitToolOutputs } from './threads/runs/submitToolOutputs'\nimport { assistants } from './assistants'\nimport { fileRegexp } from '@/lib/files/fileRegexp'\nimport { fileContentRegexp } from '@/lib/files/fileContentRegexp'\nimport { file } from './files/get'\nimport { fileContent } from './files/content'\n\ntype MethodHandlers = { get?: RequestHandler; post?: RequestHandler }\n\ntype AzureAgentsStorageAdapterArgs = StorageAdapterArgs & {\n runAdapter: RunAdapterWithAssistant\n}\n\nexport const azureAgentsStorageAdapter = ({\n azureAiProject,\n prisma,\n}: {\n azureAiProject: AIProjectClient\n prisma: PrismaClient\n}) => {\n return ({ runAdapter }: AzureAgentsStorageAdapterArgs) => ({\n requestHandlers: {\n '^/(?:v1\|/?openai)/assistants$': assistants({ runAdapter }),\n '^/(?:v1\|/?openai)/threads$': threads({ azureAiProject }),\n [messagesRegexp]: messages({ azureAiProject, runAdapter }),\n [runsRegexp]: runs({ azureAiProject, runAdapter }),\n [runRegexp]: run({ azureAiProject, runAdapter }),\n [stepsRegexp]: steps({ azureAiProject, runAdapter, prisma }),\n [submitToolOutputsRegexp]: submitToolOutputs({ azureAiProject, runAdapter, prisma }),\n [fileRegexp]: file({ azureAiProject }),\n [fileContentRegexp]: fileContent({ azureAiProject }),\n },\n })\n}\n","import dayjs from 'dayjs'\nimport { uid } from 'radash'\nimport type OpenAI from 'openai'\nimport { serializeResponseAsRun } from '@/lib/responses/serializeResponseAsRun'\nimport { serializeItemAsMessage } from '@/lib/items/serializeItemAsMessage'\nimport { serializeItemAsMessageCreationRunStep } from '@/lib/items/serializeItemAsMessageCreationRunStep'\nimport { saveResponseItemsToConversationMetadata } from '@/lib/responses/saveResponseItemsToConversationMetadata'\nimport { serializeItemAsImageGenerationRunStep } from '@/lib/items/serializeItemAsImageGenerationRunStep'\nimport { serializeItemAsWebSearchRunStep } from '@/lib/items/serializeItemAsWebSearchRunStep'\nimport { serializeItemAsMcpListToolsRunStep } from '@/lib/items/serializeItemAsMcpListToolsRunStep'\nimport { serializeItemAsMcpCallRunStep } from '@/lib/items/serializeItemAsMcpCallRunStep'\nimport { serializeItemAsCodeInterpreterCallRunStep } from '@/lib/items/serializeItemAsCodeInterpreterCallRunStep'\nimport { serializeItemAsComputerCallRunStep } from '@/lib/items/serializeItemAsComputerCallRunStep'\nimport { serializeItemAsReasoningRunStep } from '@/lib/items/serializeItemAsReasoningRunStep'\n\ntype Args = {\n select?: {\n id?: boolean;\n };\n}\n\ntype NormalizedArgs = {\n select: {\n id: boolean;\n };\n};\n\nconst serializeToolCalls = ({\n toolCalls,\n}: {\n toolCalls: Array<OpenAI.Responses.ResponseFunctionToolCall \| OpenAI.Responses.ResponseComputerToolCall>\n}) => (\n toolCalls.map((toolCall) => {\n if (toolCall.type === 'function_call') {\n return {\n id: toolCall.call_id,\n type: 'function' as const,\n function: {\n name: toolCall.name,\n arguments: toolCall.arguments,\n },\n }\n } else if (toolCall.type === 'computer_call') {\n return {\n id: toolCall.call_id,\n type: 'computer_call' as const,\n computer_call: {\n action: toolCall.action,\n pending_safety_checks: toolCall.pending_safety_checks,\n },\n }\n }\n }) as OpenAI.Beta.Threads.Runs.RequiredActionFunctionToolCall[]\n)\n\nexport const responsesRunAdapter =\n ({\n getOpenaiAssistant: getDirectOpenaiAssistant,\n waitUntil = <T>(p: Promise<T>) => p.then(() => {})\n }: {\n getOpenaiAssistant: (args?: Args) => Promise<OpenAI.Beta.Assistants.Assistant> \| OpenAI.Beta.Assistants.Assistant \| Pick<OpenAI.Beta.Assistants.Assistant, 'id'> \| Promise<Pick<OpenAI.Beta.Assistants.Assistant, 'id'>>\n waitUntil?: <T>(p: Promise<T>) => void \| Promise<void>\n }) => {\n let cachedOpenaiAssistant: OpenAI.Beta.Assistants.Assistant \| null = null\n\n const getOpenaiAssistant = async ({ select: { id = false } = {} }: Args = {}) => {\n const args: NormalizedArgs = { select: { id } }\n\n if (args.select.id) {\n return {\n id: (await getDirectOpenaiAssistant({ select: { id: true } })).id,\n }\n }\n\n if (cachedOpenaiAssistant) return cachedOpenaiAssistant\n\n cachedOpenaiAssistant = await getDirectOpenaiAssistant() as OpenAI.Beta.Assistants.Assistant\n return cachedOpenaiAssistant\n }\n\n const handleRun = async ({\n client,\n threadId,\n response,\n onEvent,\n }: {\n client: OpenAI\n threadId: string\n response: AsyncIterable<any>\n onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<any>\n }) => {\n let responseCreatedResponse: OpenAI.Responses.Response \| null = null\n let responseCompletedResponse: OpenAI.Responses.Response \| null = null\n const toolCalls: Record<string, OpenAI.Responses.ResponseFunctionToolCall> = {}\n const mcpCalls: Record<string, OpenAI.Responses.ResponseItem.McpCall> = {}\n const codeInterpreterCalls: Record<string, OpenAI.Responses.ResponseCodeInterpreterToolCall> = {}\n\n let itemIds: string[] = []\n\n try {\n for await (const event of response as AsyncIterable<OpenAI.Responses.ResponseStreamEvent>) {\n switch (event.type) {\n case 'response.created':\n responseCreatedResponse = event.response\n\n await onEvent({\n event: 'thread.run.created',\n data: serializeResponseAsRun({\n response: event.response,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id,\n }),\n })\n break\n\n case 'response.in_progress':\n await onEvent({\n event: 'thread.run.in_progress',\n data: serializeResponseAsRun({\n response: event.response,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id,\n }),\n })\n break\n\n case 'response.completed': {\n responseCompletedResponse = event.response\n itemIds = event.response.output.filter((o) => o.id).map((o) => o.id!)\n break\n }\n\n case 'response.failed': {\n await onEvent({\n event: 'thread.run.failed',\n data: serializeResponseAsRun({\n response: event.response,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id,\n }),\n })\n break\n }\n\n case 'response.output_text.delta': {\n await onEvent({\n event: 'thread.message.delta',\n data: {\n id: event.item_id,\n delta: {\n content: [{ type: 'text', index: event.content_index, text: { value: event.delta } }],\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent.ThreadMessageDelta)\n\n break\n }\n\n // case 'response.output_text.done': {\n // break\n // }\n //\n case 'response.output_item.added': {\n if (event.item.type === 'message') {\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n } else if (event.item.type === 'function_call') {\n toolCalls[event.item.id!] = event.item\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'computer_call') {\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsComputerCallRunStep({\n item: event.item,\n items: [],\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n completedAt: null,\n })\n })\n } else if (event.item.type === 'image_generation_call') {\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsImageGenerationRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n } else if (event.item.type === 'reasoning') {\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsReasoningRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n completedAt: null,\n })\n })\n } else if (event.item.type === 'web_search_call') {\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsWebSearchRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n completedAt: null,\n })\n })\n } else if (event.item.type === 'mcp_list_tools') {\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMcpListToolsRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n completedAt: null,\n })\n })\n } else if (event.item.type === 'mcp_call') {\n mcpCalls[event.item.id!] = event.item\n\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMcpCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n completedAt: null,\n })\n })\n } else if (event.item.type === 'code_interpreter_call') {\n codeInterpreterCalls[event.item.id!] = event.item\n\n await onEvent({\n event: 'thread.message.created',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n status: 'in_progress',\n completedAt: null,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.created',\n data: serializeItemAsCodeInterpreterCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n completedAt: null,\n })\n })\n }\n\n if (event.item.id) itemIds.push(event.item.id)\n\n break\n }\n\n case 'response.output_item.done': {\n if (event.item.type === 'message') {\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.message.completed',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'function_call') {\n toolCalls[event.item.id!] = event.item\n\n await onEvent({\n event: 'thread.run.step.in_progress',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'image_generation_call') {\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsImageGenerationRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.message.completed',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'reasoning') {\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsReasoningRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.message.completed',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'web_search_call') {\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsWebSearchRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.message.completed',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'mcp_list_tools') {\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMcpListToolsRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.message.completed',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'mcp_call') {\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMcpCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.message.completed',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n })\n })\n } else if (event.item.type === 'code_interpreter_call') {\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsCodeInterpreterCallRunStep({\n item: event.item,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n threadId,\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.run.step.completed',\n data: serializeItemAsMessageCreationRunStep({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n runId: responseCreatedResponse!.id,\n })\n })\n\n await onEvent({\n event: 'thread.message.completed',\n data: serializeItemAsMessage({\n item: event.item,\n threadId,\n openaiAssistant: await getOpenaiAssistant({ select: { id: true } }),\n createdAt: dayjs().unix(),\n runId: responseCreatedResponse!.id,\n })\n })\n }\n\n break\n }\n\n case 'response.function_call_arguments.delta': {\n const toolCall = toolCalls[event.item_id]\n if (!toolCall) break\n\n await onEvent({\n event: 'thread.run.step.delta',\n data: {\n id: event.item_id,\n object: 'thread.run.step.delta',\n delta: {\n step_details: {\n type: 'tool_calls',\n tool_calls: [\n {\n id: toolCall.call_id,\n type: 'function',\n index: event.output_index,\n function: {\n name: toolCall.name,\n arguments: event.delta,\n output: null,\n },\n },\n ],\n },\n },\n }\n })\n\n break\n }\n\n case 'response.mcp_call_arguments.delta': {\n const mcpCall = mcpCalls[event.item_id]\n if (!mcpCall) break\n\n await onEvent({\n event: 'thread.run.step.delta',\n data: {\n id: `fc${event.item_id}`,\n object: 'thread.run.step.delta',\n delta: {\n step_details: {\n type: 'tool_calls',\n tool_calls: [\n {\n id: `ftc${mcpCall.id}`,\n type: 'function',\n index: event.output_index,\n function: {\n name: mcpCall.name,\n arguments: event.delta,\n output: null,\n },\n },\n ],\n },\n },\n }\n })\n\n break\n }\n\n case 'response.image_generation_call.in_progress':\n case 'response.image_generation_call.generating':\n await onEvent({\n event: 'thread.message.in_progress',\n data: {\n id: event.item_id,\n object: 'thread.message' as 'thread.message',\n created_at: dayjs().unix(),\n thread_id: threadId,\n completed_at: null,\n incomplete_at: null,\n incomplete_details: null,\n role: 'assistant' as 'assistant',\n content: [],\n assistant_id: (await getOpenaiAssistant({ select: { id: true } })).id,\n run_id: responseCreatedResponse!.id,\n attachments: [],\n status: 'in_progress' as 'in_progress',\n metadata: {\n event: JSON.stringify(event),\n },\n },\n })\n\n break\n\n case 'response.image_generation_call.partial_image': {\n await onEvent({\n event: 'thread.message.in_progress',\n data: {\n id: event.item_id,\n object: 'thread.message' as 'thread.message',\n created_at: dayjs().unix(),\n thread_id: threadId,\n completed_at: null,\n incomplete_at: null,\n incomplete_details: null,\n role: 'assistant' as 'assistant',\n content: [{\n type: 'image_url' as 'image_url',\n image_url: {\n url: `data:image/png;base64,${event.partial_image_b64}`,\n // url: `data:image/png;base64,truncated`,\n detail: 'auto' as 'auto',\n },\n }],\n assistant_id: (await getOpenaiAssistant({ select: { id: true } })).id,\n run_id: responseCreatedResponse!.id,\n attachments: [],\n status: 'in_progress' as 'in_progress',\n metadata: {\n event: JSON.stringify({\n ...event,\n partial_image_b64: 'truncated',\n }),\n },\n },\n })\n\n break\n }\n\n //\n // case 'response.function_call_arguments.done': {\n // break\n // }\n\n default:\n break\n }\n }\n if (responseCompletedResponse) {\n const toolCalls = (responseCompletedResponse.output ?? []).filter(\n (o): o is OpenAI.Responses.ResponseFunctionToolCall \| OpenAI.Responses.ResponseComputerToolCall =>\n o.type === 'function_call' \|\| o.type === 'computer_call',\n )\n\n const serializedRun = serializeResponseAsRun({\n response: responseCompletedResponse,\n assistantId: (await getOpenaiAssistant({ select: { id: true } })).id,\n })\n\n if (toolCalls.length > 0) {\n await onEvent({\n event: 'thread.run.requires_action',\n data: {\n ...serializedRun,\n status: 'requires_action',\n required_action: {\n type: 'submit_tool_outputs',\n submit_tool_outputs: {\n tool_calls: serializeToolCalls({ toolCalls }),\n },\n },\n },\n })\n } else {\n await onEvent({\n event: 'thread.run.completed',\n data: serializedRun,\n })\n }\n }\n } catch (e: any) {\n await onEvent({\n event: 'thread.run.failed',\n data: {\n id: responseCreatedResponse?.id \|\| `run_${uid(18)}`,\n object: 'thread.run',\n thread_id: threadId,\n assistant_id: (await getOpenaiAssistant({ select: { id: true } })).id,\n status: 'failed',\n failed_at: dayjs().unix(),\n last_error: {\n code: 'server_error',\n message: String(e?.message \|\| e \|\| 'Unknown error'),\n },\n } as any,\n })\n } finally {\n waitUntil(new Promise(async (resolve) => {\n if (responseCreatedResponse?.id && itemIds.length > 0) {\n await saveResponseItemsToConversationMetadata({\n client,\n threadId,\n responseId: responseCreatedResponse.id,\n itemIds,\n })\n }\n\n resolve(true)\n }))\n }\n }\n\n return {\n handleRun,\n getOpenaiAssistant,\n }\n }\n","import dayjs from 'dayjs'\nimport type OpenAI from 'openai'\nimport type { AIProjectClient } from '@azure/ai-projects'\nimport { uid } from 'radash'\n\n// Helper function to transform annotations from Azure's camelCase to OpenAI's snake_case\nfunction transformAnnotations(annotations: any[]): any[] {\n return annotations.map((ann: any) => {\n if (ann.type === 'file_citation') {\n return {\n type: 'file_citation' as const,\n text: ann.text,\n start_index: ann.startIndex ?? ann.start_index,\n end_index: ann.endIndex ?? ann.end_index,\n file_citation: {\n file_id: ann.fileCitation?.fileId \|\| ann.file_citation?.file_id,\n quote: ann.fileCitation?.quote \|\| ann.file_citation?.quote \|\| '',\n },\n }\n } else if (ann.type === 'file_path') {\n return {\n type: 'file_path' as const,\n text: ann.text,\n start_index: ann.startIndex ?? ann.start_index,\n end_index: ann.endIndex ?? ann.end_index,\n file_path: {\n file_id: ann.filePath?.fileId \|\| ann.file_path?.file_id,\n },\n }\n }\n return ann\n })\n}\n\nfunction transformMessageContentItem(content: any) {\n if (content.type === 'text') {\n return {\n type: 'text' as const,\n text: {\n value: content.text?.value \|\| '',\n annotations: transformAnnotations(content.text?.annotations \|\| []),\n },\n }\n }\n\n if (content.type === 'image_file') {\n const imageFile = content.image_file \|\| content.imageFile \|\| {}\n return {\n type: 'image_file' as const,\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| '',\n detail: imageFile.detail ?? 'auto',\n },\n }\n }\n\n return content\n}\n\nfunction transformMessageDeltaContentItem(content: any) {\n if (content.type === 'text') {\n return {\n index: content.index \|\| 0,\n type: 'text' as const,\n text: {\n value: content.text?.value \|\| '',\n annotations: transformAnnotations(content.text?.annotations \|\| []),\n },\n }\n }\n\n if (content.type === 'image_file') {\n const imageFile = content.image_file \|\| content.imageFile \|\| {}\n return {\n index: content.index \|\| 0,\n type: 'image_file' as const,\n image_file: {\n file_id: imageFile.file_id \|\| imageFile.fileId \|\| '',\n detail: imageFile.detail ?? 'auto',\n },\n }\n }\n\n return content\n}\n\n// Convert Azure Agent event to OpenAI Assistant event\nfunction convertAzureEventToOpenAI(\n azureEvent: any,\n assistantId: string,\n): OpenAI.Beta.AssistantStreamEvent \| null {\n const { event, data } = azureEvent\n\n // Map Azure event types to OpenAI event types (they're mostly 1:1)\n const eventType = event as string\n\n // Convert Azure data to OpenAI format based on event type\n // IMPORTANT: Exclude step events from the general run handler, they have their own handler below\n if (eventType.startsWith('thread.run.') && !eventType.startsWith('thread.run.step.')) {\n // Convert ThreadRun to OpenAI Run\n return {\n event: eventType as any,\n data: {\n id: data.id,\n object: 'thread.run',\n created_at: dayjs(data.createdAt).unix(),\n thread_id: data.threadId,\n assistant_id: assistantId,\n status: data.status,\n required_action: data.requiredAction\n ? {\n type: 'submit_tool_outputs',\n submit_tool_outputs: {\n tool_calls: (data.requiredAction as any).submitToolOutputs?.toolCalls?.map(\n (tc: any) => ({\n id: tc.id,\n type: 'function' as const,\n function: {\n name: tc.function.name,\n arguments: tc.function.arguments,\n },\n }),\n ) \|\| [],\n },\n }\n : null,\n last_error: data.lastError\n ? {\n code: 'server_error',\n message: JSON.stringify(data.lastError),\n }\n : null,\n expires_at: null,\n started_at: data.startedAt ? dayjs(data.startedAt).unix() : null,\n cancelled_at: data.cancelledAt ? dayjs(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? dayjs(data.failedAt).unix() : null,\n completed_at: data.completedAt ? dayjs(data.completedAt).unix() : null,\n incomplete_details: null,\n model: data.model \|\| '',\n instructions: data.instructions \|\| '',\n tools: data.tools \|\| [],\n metadata: data.metadata \|\| {},\n temperature: data.temperature ?? null,\n top_p: data.topP ?? null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: 'auto',\n last_messages: null,\n },\n response_format: 'auto',\n tool_choice: 'auto',\n parallel_tool_calls: true,\n usage: null,\n } as OpenAI.Beta.Threads.Run,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType.startsWith('thread.message.') && eventType !== 'thread.message.delta') {\n // Convert ThreadMessage to OpenAI Message\n return {\n event: eventType as any,\n data: {\n id: data.id,\n object: 'thread.message',\n created_at: dayjs(data.createdAt).unix(),\n thread_id: data.threadId,\n role: data.role,\n content: data.content?.map((c: any) => transformMessageContentItem(c)) \|\| [],\n assistant_id: assistantId,\n run_id: data.runId \|\| null,\n attachments: data.attachments \|\| [],\n metadata: data.metadata \|\| {},\n status: data.status \|\| 'completed',\n completed_at: data.completedAt ? dayjs(data.completedAt).unix() : null,\n incomplete_at: null,\n incomplete_details: null,\n } as OpenAI.Beta.Threads.Message,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType === 'thread.message.delta') {\n // Convert MessageDeltaChunk to OpenAI MessageDelta\n return {\n event: 'thread.message.delta' as any,\n data: {\n id: data.id,\n object: 'thread.message.delta',\n delta: {\n content: data.delta?.content?.map((c: any) => transformMessageDeltaContentItem(c)) \|\| [],\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType === 'thread.run.step.delta') {\n // Handle run step delta events separately - they have delta.stepDetails\n // Skip delta events where stepDetails is missing or has no type - these are incomplete\n if (!data.delta?.stepDetails \|\| !data.delta.stepDetails.type) {\n return null\n }\n\n let stepDetailsDelta: any = undefined\n\n if (data.delta?.stepDetails) {\n const details = data.delta.stepDetails\n if (details.type === 'tool_calls') {\n stepDetailsDelta = {\n type: 'tool_calls',\n tool_calls: details.toolCalls?.map((tc: any) => {\n if (tc.type === 'code_interpreter') {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: 'code_interpreter',\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| '',\n outputs: tc.codeInterpreter?.outputs?.map((output: any) => {\n if (output.type === 'logs') {\n return {\n index: output.index ?? 0,\n type: 'logs',\n logs: output.logs \|\| '',\n }\n }\n if (output.type === 'image') {\n return {\n index: output.index ?? 0,\n type: 'image',\n image: {\n file_id: output.image?.fileId \|\| '',\n },\n }\n }\n return output\n }) \|\| [],\n },\n }\n } else if (tc.type === 'file_search') {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: 'file_search',\n file_search: tc.fileSearch \|\| {},\n }\n } else if (tc.type === 'function') {\n return {\n index: tc.index ?? 0,\n id: tc.id,\n type: 'function',\n function: {\n name: tc.function?.name \|\| '',\n arguments: tc.function?.arguments \|\| '',\n output: tc.function?.output \|\| null,\n },\n }\n }\n return tc\n }) \|\| [],\n }\n } else {\n stepDetailsDelta = details\n }\n }\n\n // Final safety check: if stepDetailsDelta is still undefined after processing, skip this event\n if (stepDetailsDelta === undefined) {\n return null\n }\n\n return {\n event: 'thread.run.step.delta' as any,\n data: {\n id: data.id,\n object: 'thread.run.step.delta',\n delta: {\n step_details: stepDetailsDelta,\n },\n },\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType.startsWith('thread.run.step.')) {\n // Convert RunStep events with proper snake_case transformation\n // Skip events where stepDetails is missing, has no type, or where the step type is undefined\n // Azure sometimes sends incomplete step events during file_search initialization\n if (!data.stepDetails \|\| !data.stepDetails.type \|\| !data.type) {\n return null\n }\n\n let stepDetails: any = undefined\n\n if (data.stepDetails) {\n if (data.stepDetails.type === 'message_creation') {\n stepDetails = {\n type: 'message_creation',\n message_creation: {\n message_id: data.stepDetails.messageCreation?.messageId \|\| '',\n },\n }\n } else if (data.stepDetails.type === 'tool_calls') {\n stepDetails = {\n type: 'tool_calls',\n tool_calls: data.stepDetails.toolCalls?.map((tc: any) => {\n if (tc.type === 'code_interpreter') {\n return {\n id: tc.id,\n type: 'code_interpreter',\n code_interpreter: {\n input: tc.codeInterpreter?.input \|\| '',\n outputs: tc.codeInterpreter?.outputs?.map((output: any) => {\n if (output.type === 'logs') {\n return {\n type: 'logs',\n logs: output.logs \|\| '',\n }\n }\n if (output.type === 'image') {\n return {\n type: 'image',\n image: {\n file_id: output.image?.fileId \|\| '',\n },\n }\n }\n return output\n }) \|\| [],\n },\n }\n } else if (tc.type === 'file_search') {\n return {\n id: tc.id,\n type: 'file_search',\n file_search: tc.fileSearch \|\| {},\n }\n } else if (tc.type === 'function') {\n return {\n id: tc.id,\n type: 'function',\n function: {\n name: tc.function?.name \|\| '',\n arguments: tc.function?.arguments \|\| '',\n output: tc.function?.output \|\| null,\n },\n }\n }\n return tc\n }) \|\| [],\n }\n } else {\n // Unknown type, pass through\n stepDetails = data.stepDetails\n }\n }\n\n // Final safety check: if stepDetails is still undefined after processing, skip this event\n // This prevents OpenAI SDK from crashing on incomplete events\n if (stepDetails === undefined) {\n return null\n }\n\n return {\n event: eventType as any,\n data: {\n id: data.id,\n object: 'thread.run.step',\n created_at: dayjs(data.createdAt).unix(),\n assistant_id: assistantId,\n thread_id: data.threadId,\n run_id: data.runId,\n type: data.type,\n status: data.status,\n step_details: stepDetails,\n last_error: data.lastError \|\| null,\n expired_at: null,\n cancelled_at: data.cancelledAt ? dayjs(data.cancelledAt).unix() : null,\n failed_at: data.failedAt ? dayjs(data.failedAt).unix() : null,\n completed_at: data.completedAt ? dayjs(data.completedAt).unix() : null,\n metadata: data.metadata \|\| {},\n usage: null,\n } as OpenAI.Beta.Threads.Runs.RunStep,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n if (eventType === 'thread.created') {\n return {\n event: 'thread.created' as any,\n data: {\n id: data.id,\n object: 'thread',\n created_at: dayjs(data.createdAt).unix(),\n metadata: data.metadata \|\| {},\n tool_resources: data.toolResources \|\| null,\n } as OpenAI.Beta.Threads.Thread,\n } as OpenAI.Beta.AssistantStreamEvent\n }\n\n // Return null for unhandled event types\n return null\n}\n\nexport const azureAgentsRunAdapter = ({\n azureAiProject,\n}: {\n azureAiProject: AIProjectClient\n}) => {\n const handleRun = async ({\n threadId,\n assistantId,\n instructions,\n tools,\n onEvent,\n }: {\n threadId: string\n assistantId: string\n instructions?: string\n tools?: any[]\n onEvent: (event: OpenAI.Beta.AssistantStreamEvent) => Promise<any>\n }) => {\n try {\n // assistantId from OpenAI API maps to azureAgentId\n const azureAgentId = assistantId\n\n // Build the options object for Azure run creation\n const createOptions: any = {}\n if (instructions) {\n createOptions.instructions = instructions\n }\n if (tools) {\n createOptions.tools = tools\n }\n\n // Create the run with streaming support\n const runResponse = azureAiProject.agents.runs.create(\n threadId,\n azureAgentId,\n createOptions,\n )\n\n // Start streaming\n const stream = await runResponse.stream()\n\n // Convert Azure events to OpenAI events and emit them\n for await (const azureEvent of stream) {\n const openaiEvent = convertAzureEventToOpenAI(azureEvent, assistantId)\n if (openaiEvent) {\n await onEvent(openaiEvent)\n }\n }\n } catch (e: any) {\n // Generate a unique run ID for the failed run\n const errorRunId = `run_${uid(18)}`\n await onEvent({\n event: 'thread.run.failed',\n data: {\n id: errorRunId,\n object: 'thread.run',\n created_at: dayjs().unix(),\n thread_id: threadId,\n assistant_id: assistantId,\n status: 'failed',\n required_action: null,\n last_error: {\n code: 'server_error',\n message: String(e?.message \|\| e \|\| 'Unknown error'),\n },\n expires_at: null,\n started_at: dayjs().unix(),\n cancelled_at: null,\n failed_at: dayjs().unix(),\n completed_at: null,\n incomplete_details: null,\n model: '',\n instructions: '',\n tools: [],\n metadata: {},\n temperature: null,\n top_p: null,\n max_prompt_tokens: null,\n max_completion_tokens: null,\n truncation_strategy: {\n type: 'auto',\n last_messages: null,\n },\n response_format: 'auto',\n tool_choice: 'auto',\n parallel_tool_calls: true,\n usage: null,\n } as OpenAI.Beta.Threads.Run,\n })\n }\n }\n\n return {\n handleRun,\n }\n}\n"]}
1	+ {"version":3,"sources":["/Users/domas/Developer/supercorp/supercompat/packages/supercompat/dist/index.cjs","../src/index.ts"],"names":["__defProp","Object","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__hasOwnProp","prototype","hasOwnProperty","__copyProps","to","from","except","desc","key","call","get","enumerable","__toCommonJS","mod","value","index_exports","module","exports"],"mappings":"AAAA;;;;;AACA,IAAIA,YAAYC,OAAOC,cAAc;AACrC,IAAIC,mBAAmBF,OAAOG,wBAAwB;AACtD,IAAIC,oBAAoBJ,OAAOK,mBAAmB;AAClD,IAAIC,eAAeN,OAAOO,SAAS,CAACC,cAAc;AAClD,IAAIC,cAAc,SAACC,IAAIC,MAAMC,QAAQC;IACnC,IAAIF,QAAQ,CAAA,OAAOA,qCAAP,SAAOA,KAAG,MAAM,YAAY,OAAOA,SAAS,YAAY;YAC7D,kCAAA,2BAAA;;;gBAAA,IAAIG,MAAJ;gBACH,IAAI,CAACR,aAAaS,IAAI,CAACL,IAAII,QAAQA,QAAQF,QACzCb,UAAUW,IAAII,KAAK;oBAAEE,KAAK;+BAAML,IAAI,CAACG,IAAI;;oBAAEG,YAAY,CAAEJ,CAAAA,OAAOX,iBAAiBS,MAAMG,IAAG,KAAMD,KAAKI,UAAU;gBAAC;;YAFpH,QAAK,YAAWb,kBAAkBO,0BAA7B,SAAA,6BAAA,QAAA,yBAAA;;YAAA;YAAA;;;qBAAA,6BAAA;oBAAA;;;oBAAA;0BAAA;;;;IAGP;IACA,OAAOD;AACT;AACA,IAAIQ,eAAe,SAACC;WAAQV,YAAYV,UAAU,CAAC,GAAG,cAAc;QAAEqB,OAAO;IAAK,IAAID;;AAEtF,eAAe;ACff,IAAAE,gBAAA,CAAA;AAAAC,OAAAC,OAAA,GAAAL,aAAAG","sourcesContent":["\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __copyProps = (to, from, except, desc) => {\n if (from && typeof from === \"object\" \|\| typeof from === \"function\") {\n for (let key of __getOwnPropNames(from))\n if (!__hasOwnProp.call(to, key) && key !== except)\n __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });\n }\n return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/index.ts\nvar index_exports = {};\nmodule.exports = __toCommonJS(index_exports);\n","// Import from 'supercompat/openai' instead.\nexport {}\n"]}