From 05e47611f0e69449574cd11428c4efce498a72c8 Mon Sep 17 00:00:00 2001 From: Lembot Date: Fri, 9 Jan 2026 15:12:36 -0500 Subject: [PATCH 1/3] feat: Embedded local worker for offline/local mode (v0.3.4) Implement inline worker creation using embedded worker bundle: - Add separate webpack configs for worker and main bundles - Worker is built first, then embedded as base64 in TypeScript - WorkerWrapper creates inline worker via Blob URL when URL not provided - Version number now injected at build time from package.json This enables ai-delegate to work without requiring a separate worker file to be served, useful for offline/local development scenarios. Co-Authored-By: Claude Opus 4.5 --- example-project/public/test-inline.html | 60 +++++++++++++ package.json | 15 ++-- scripts/embed-worker.js | 104 ++++++++++++++++++++++ src/core/AiDelegate.ts | 18 +--- src/worker/WorkerWrapper.ts | 30 +++++-- src/worker/embedded-worker.ts | 53 +++++++++++ src/worker/worker.ts | 5 +- webpack.main.config.js | 111 ++++++++++++++++++++++++ webpack.worker.config.js | 38 ++++++++ 9 files changed, 409 insertions(+), 25 deletions(-) create mode 100644 example-project/public/test-inline.html create mode 100755 scripts/embed-worker.js create mode 100644 src/worker/embedded-worker.ts create mode 100644 webpack.main.config.js create mode 100644 webpack.worker.config.js diff --git a/example-project/public/test-inline.html b/example-project/public/test-inline.html new file mode 100644 index 0000000..7a29291 --- /dev/null +++ b/example-project/public/test-inline.html @@ -0,0 +1,60 @@ + + + + Inline Worker Test + + + +

AI-Delegate Inline Worker Test

+

This test verifies the inline worker works without a server.

+
+ + + + + diff --git a/package.json b/package.json index 033d592..c16c13c 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@peerverity/ai-delegate", - "version": "0.3.3", + "version": "0.3.4", "description": "AI request manager with credential management and weight-based model selection", "main": "dist/ai-delegate.js", "types": "dist/index.d.ts", @@ -25,12 +25,17 @@ "dist" ], "scripts": { - "build": "webpack --mode production && npm run build:types", - "build:dev": "webpack --mode development && npm run build:types", + "build": "npm run build:worker && npm run embed-worker && npm run build:main && npm run build:types", + "build:dev": "npm run build:worker:dev && npm run embed-worker && npm run build:main:dev && npm run build:types", + "build:worker": "webpack --mode production --config webpack.worker.config.js", + "build:worker:dev": "webpack --mode development --config webpack.worker.config.js", + "build:main": "webpack --mode production --config webpack.main.config.js", + "build:main:dev": "webpack --mode development --config webpack.main.config.js", "build:types": "tsc --emitDeclarationOnly --declaration --declarationMap", + "embed-worker": "node scripts/embed-worker.js", "prepare": "npm run build", - "watch": "webpack --mode development --watch", - "clean": "rimraf dist", + "watch": "npm run build:worker:dev && npm run embed-worker && webpack --mode development --config webpack.main.config.js --watch", + "clean": "rimraf dist src/worker/embedded-worker.ts", "serve": "node scripts/serve.js", "example:install": "npm --prefix example-project install", "example:start": "npm --prefix example-project start", diff --git a/scripts/embed-worker.js b/scripts/embed-worker.js new file mode 100755 index 0000000..20bdaec --- /dev/null +++ b/scripts/embed-worker.js @@ -0,0 +1,104 @@ +#!/usr/bin/env node +/** + * Embeds the compiled worker bundle into a TypeScript file + * that can be imported by the main bundle. + * + * This enables inline worker creation via Blob URL for offline/local mode. + * + * We use base64 encoding to safely embed the worker code without escaping issues. + */ + +const fs = require('fs'); +const path = require('path'); + +const WORKER_PATH = path.resolve(__dirname, '../dist/ai-delegate-worker.js'); +const OUTPUT_PATH = path.resolve(__dirname, '../src/worker/embedded-worker.ts'); + +function embedWorker() { + console.log('[embed-worker] Reading worker bundle...'); + + if (!fs.existsSync(WORKER_PATH)) { + console.error(`[embed-worker] ERROR: Worker bundle not found at ${WORKER_PATH}`); + console.error('[embed-worker] Run "npm run build:worker" first.'); + process.exit(1); + } + + const workerCode = fs.readFileSync(WORKER_PATH, 'utf8'); + const version = extractVersion(workerCode); + + // Base64 encode the worker code to avoid any escaping issues + const base64Code = Buffer.from(workerCode, 'utf8').toString('base64'); + + const output = `/** + * AUTO-GENERATED FILE - DO NOT EDIT + * + * This file contains the embedded worker bundle for inline worker creation. + * Generated by scripts/embed-worker.js + * + * To regenerate: npm run build:worker && npm run embed-worker + */ + +/** + * The worker source code as a base64-encoded string. + */ +const EMBEDDED_WORKER_BASE64 = '${base64Code}'; + +/** + * Decode the base64-encoded worker source. + */ +function decodeWorkerSource(): string { + // Use atob for browser environment + if (typeof atob === 'function') { + return atob(EMBEDDED_WORKER_BASE64); + } + // Fallback for Node.js environment (for testing) + return Buffer.from(EMBEDDED_WORKER_BASE64, 'base64').toString('utf8'); +} + +/** + * The worker source code as a string. + * Lazily decoded on first access. + */ +let _cachedSource: string | null = null; +export function getWorkerSource(): string { + if (_cachedSource === null) { + _cachedSource = decodeWorkerSource(); + } + return _cachedSource; +} + +/** + * Creates a Blob URL for the embedded worker. + * The URL should be revoked with URL.revokeObjectURL() when no longer needed. + */ +export function createWorkerBlobUrl(): string { + const source = getWorkerSource(); + const blob = new Blob([source], { type: 'application/javascript' }); + return URL.createObjectURL(blob); +} + +/** + * Version marker to help with debugging cache issues. + * This is extracted from the worker bundle if present. + */ +export const EMBEDDED_WORKER_VERSION: string = '${version}'; +`; + + console.log('[embed-worker] Writing embedded worker source...'); + fs.writeFileSync(OUTPUT_PATH, output, 'utf8'); + + const stats = fs.statSync(WORKER_PATH); + const base64Size = base64Code.length; + console.log(`[embed-worker] Original size: ${(stats.size / 1024).toFixed(1)}KB`); + console.log(`[embed-worker] Base64 size: ${(base64Size / 1024).toFixed(1)}KB`); + console.log(`[embed-worker] Worker version: ${version}`); + console.log(`[embed-worker] Output: ${OUTPUT_PATH}`); +} + +function extractVersion(code) { + // Try to extract version from worker code (looks for Version: X.Y.Z pattern) + const match = code.match(/Version:\s*([\d.]+)/); + return match ? match[1] : 'unknown'; +} + +embedWorker(); diff --git a/src/core/AiDelegate.ts b/src/core/AiDelegate.ts index 54891b6..77a5c64 100644 --- a/src/core/AiDelegate.ts +++ b/src/core/AiDelegate.ts @@ -123,8 +123,10 @@ export class AiDelegate { return; } - const workerUrl = this.getWorkerUrl(); - await this.worker.initialize(workerUrl, this.credentialServerUrl, this.allowLocalMode); + await this.worker.initialize( + this.credentialServerUrl, + this.allowLocalMode + ); // Set up prompt handler for worker this.setupPromptHandler(); @@ -151,18 +153,6 @@ export class AiDelegate { } } - /** - * Get the URL for the worker script based on the configured endpoint - */ - private getWorkerUrl(): string { - if (!this.endpoint) { - throw new Error('Cannot get worker URL: endpoint not configured'); - } - - // Worker is served at the endpoint path - return `${this.endpoint}/ai-delegate-worker.js`; - } - /** * Set up handler for prompt requests from worker */ diff --git a/src/worker/WorkerWrapper.ts b/src/worker/WorkerWrapper.ts index 5eb7262..9451f48 100644 --- a/src/worker/WorkerWrapper.ts +++ b/src/worker/WorkerWrapper.ts @@ -17,6 +17,7 @@ import { InitPayload } from './types'; import { MessageProtocol } from './MessageProtocol'; +import { createWorkerBlobUrl, EMBEDDED_WORKER_VERSION } from './embedded-worker'; /** * Main thread wrapper for worker communication @@ -24,6 +25,7 @@ import { MessageProtocol } from './MessageProtocol'; */ export class WorkerWrapper { private worker: Worker | null = null; + private blobUrl: string | null = null; // Track blob URL for cleanup private pendingRequests: Map void; reject: (error: Error) => void; @@ -32,22 +34,25 @@ export class WorkerWrapper { /** * Initialize the worker - * @param workerUrl - URL to the worker script * @param credentialServerUrl - Optional URL of the credential server for proxied mode * @param allowLocalMode - Whether to allow users to switch to local mode */ - async initialize(workerUrl: string, credentialServerUrl?: string, allowLocalMode?: boolean): Promise { + async initialize( + credentialServerUrl?: string, + allowLocalMode?: boolean + ): Promise { if (this.worker) { return; // Already initialized } - this.worker = new Worker(workerUrl); + // Always use inline worker via Blob URL + this.createInlineWorker(); - this.worker.addEventListener('message', (event: MessageEvent) => { + this.worker!.addEventListener('message', (event: MessageEvent) => { this.handleWorkerMessage(event.data); }); - this.worker.addEventListener('error', (event: ErrorEvent) => { + this.worker!.addEventListener('error', (event: ErrorEvent) => { console.error('[WorkerWrapper] Worker error:', event.error); // Reject all pending requests this.pendingRequests.forEach(({ reject }) => { @@ -61,6 +66,15 @@ export class WorkerWrapper { await this.sendCommand(WorkerCommand.INIT, payload); } + /** + * Create worker from embedded source using Blob URL + */ + private createInlineWorker(): void { + console.log(`[WorkerWrapper] Creating inline worker (embedded version: ${EMBEDDED_WORKER_VERSION})`); + this.blobUrl = createWorkerBlobUrl(); + this.worker = new Worker(this.blobUrl); + } + /** * Handle messages from worker */ @@ -251,6 +265,12 @@ export class WorkerWrapper { this.worker = null; } + // Revoke blob URL if we created one + if (this.blobUrl) { + URL.revokeObjectURL(this.blobUrl); + this.blobUrl = null; + } + // Reject all pending requests this.pendingRequests.forEach(({ reject }) => { reject(new Error('Worker terminated')); diff --git a/src/worker/embedded-worker.ts b/src/worker/embedded-worker.ts new file mode 100644 index 0000000..dd61196 --- /dev/null +++ b/src/worker/embedded-worker.ts @@ -0,0 +1,53 @@ +/** + * AUTO-GENERATED FILE - DO NOT EDIT + * + * This file contains the embedded worker bundle for inline worker creation. + * Generated by scripts/embed-worker.js + * + * To regenerate: npm run build:worker && npm run embed-worker + */ + +/** + * The worker source code as a base64-encoded string. + */ +const EMBEDDED_WORKER_BASE64 = '(()=>{"use strict";class e{constructor(e,t){this.provider=e,this.modelMapping=t||{}}getModel(e){return this.modelMapping[e]}getMapping(){return{...this.modelMapping}}setModel(e,t){this.modelMapping[e]=t}updateMapping(e){this.modelMapping={...this.modelMapping,...e}}resetToDefaults(){this.modelMapping={}}clear(){this.modelMapping={}}validate(){return"string"==typeof this.modelMapping.light&&this.modelMapping.light.length>0&&"string"==typeof this.modelMapping.moderate&&this.modelMapping.moderate.length>0&&"string"==typeof this.modelMapping.heavy&&this.modelMapping.heavy.length>0}getProvider(){return this.provider}setProvider(e){this.provider=e,this.resetToDefaults()}}function t(e,t,s,r,n){if("m"===r)throw new TypeError("Private method is not writable");if("a"===r&&!n)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof t?e!==t||!n:!t.has(e))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===r?n.call(e,s):n?n.value=s:t.set(e,s),s}function s(e,t,s,r){if("a"===s&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof t?e!==t||!r:!t.has(e))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===s?r:"a"===s?r.call(e):r?r.value:t.get(e)}let r=function(){const{crypto:e}=globalThis;if(e?.randomUUID)return r=e.randomUUID.bind(e),e.randomUUID();const t=new Uint8Array(1),s=e?()=>e.getRandomValues(t)[0]:()=>255*Math.random()&255;return"10000000-1000-4000-8000-100000000000".replace(/[018]/g,e=>(+e^s()&15>>+e/4).toString(16))};function n(e){return"object"==typeof e&&null!==e&&("name"in e&&"AbortError"===e.name||"message"in e&&String(e.message).includes("FetchRequestCanceledException"))}const a=e=>{if(e instanceof Error)return e;if("object"==typeof e&&null!==e){try{if("[object Error]"===Object.prototype.toString.call(e)){const t=new Error(e.message,e.cause?{cause:e.cause}:{});return e.stack&&(t.stack=e.stack),e.cause&&!t.cause&&(t.cause=e.cause),e.name&&(t.name=e.name),t}}catch{}try{return new Error(JSON.stringify(e))}catch{}}return new Error(e)};class o extends Error{}class i extends o{constructor(e,t,s,r){super(`${i.makeMessage(e,t,s)}`),this.status=e,this.headers=r,this.requestID=r?.get("request-id"),this.error=t}static makeMessage(e,t,s){const r=t?.message?"string"==typeof t.message?t.message:JSON.stringify(t.message):t?JSON.stringify(t):s;return e&&r?`${e} ${r}`:e?`${e} status code (no body)`:r||"(no status code or body)"}static generate(e,t,s,r){if(!e||!r)return new l({message:s,cause:a(t)});const n=t;return 400===e?new h(e,n,s,r):401===e?new u(e,n,s,r):403===e?new p(e,n,s,r):404===e?new f(e,n,s,r):409===e?new m(e,n,s,r):422===e?new g(e,n,s,r):429===e?new w(e,n,s,r):e>=500?new y(e,n,s,r):new i(e,n,s,r)}}class c extends i{constructor({message:e}={}){super(void 0,void 0,e||"Request was aborted.",void 0)}}class l extends i{constructor({message:e,cause:t}){super(void 0,void 0,e||"Connection error.",void 0),t&&(this.cause=t)}}class d extends l{constructor({message:e}={}){super({message:e??"Request timed out."})}}class h extends i{}class u extends i{}class p extends i{}class f extends i{}class m extends i{}class g extends i{}class w extends i{}class y extends i{}const b=/^[a-z][a-z0-9+.-]*:/i;let v=e=>(v=Array.isArray,v(e)),_=v;function k(e){return"object"!=typeof e?{}:e??{}}const S=e=>{try{return JSON.parse(e)}catch(e){return}},M="0.71.0",P=()=>{const e="undefined"!=typeof Deno&&null!=Deno.build?"deno":"undefined"!=typeof EdgeRuntime?"edge":"[object process]"===Object.prototype.toString.call(void 0!==globalThis.process?globalThis.process:0)?"node":"unknown";if("deno"===e)return{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":R(Deno.build.os),"X-Stainless-Arch":E(Deno.build.arch),"X-Stainless-Runtime":"deno","X-Stainless-Runtime-Version":"string"==typeof Deno.version?Deno.version:Deno.version?.deno??"unknown"};if("undefined"!=typeof EdgeRuntime)return{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":"Unknown","X-Stainless-Arch":`other:${EdgeRuntime}`,"X-Stainless-Runtime":"edge","X-Stainless-Runtime-Version":globalThis.process.version};if("node"===e)return{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":R(globalThis.process.platform??"unknown"),"X-Stainless-Arch":E(globalThis.process.arch??"unknown"),"X-Stainless-Runtime":"node","X-Stainless-Runtime-Version":globalThis.process.version??"unknown"};const t=function(){if("undefined"==typeof navigator||!navigator)return null;const e=[{key:"edge",pattern:/Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"ie",pattern:/MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"ie",pattern:/Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"chrome",pattern:/Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"firefox",pattern:/Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"safari",pattern:/(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/}];for(const{key:t,pattern:s}of e){const e=s.exec(navigator.userAgent);if(e)return{browser:t,version:`${e[1]||0}.${e[2]||0}.${e[3]||0}`}}return null}();return t?{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":"Unknown","X-Stainless-Arch":"unknown","X-Stainless-Runtime":`browser:${t.browser}`,"X-Stainless-Runtime-Version":t.version}:{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":"Unknown","X-Stainless-Arch":"unknown","X-Stainless-Runtime":"unknown","X-Stainless-Runtime-Version":"unknown"}},E=e=>"x32"===e?"x32":"x86_64"===e||"x64"===e?"x64":"arm"===e?"arm":"aarch64"===e||"arm64"===e?"arm64":e?`other:${e}`:"unknown",R=e=>(e=e.toLowerCase()).includes("ios")?"iOS":"android"===e?"Android":"darwin"===e?"MacOS":"win32"===e?"Windows":"freebsd"===e?"FreeBSD":"openbsd"===e?"OpenBSD":"linux"===e?"Linux":e?`Other:${e}`:"Unknown";let x;function T(...e){const t=globalThis.ReadableStream;if(void 0===t)throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`");return new t(...e)}function A(e){let t=Symbol.asyncIterator in e?e[Symbol.asyncIterator]():e[Symbol.iterator]();return T({start(){},async pull(e){const{done:s,value:r}=await t.next();s?e.close():e.enqueue(r)},async cancel(){await(t.return?.())}})}function C(e){if(e[Symbol.asyncIterator])return e;const t=e.getReader();return{async next(){try{const e=await t.read();return e?.done&&t.releaseLock(),e}catch(e){throw t.releaseLock(),e}},async return(){const e=t.cancel();return t.releaseLock(),await e,{done:!0,value:void 0}},[Symbol.asyncIterator](){return this}}}const I=({headers:e,body:t})=>({bodyHeaders:{"content-type":"application/json"},body:JSON.stringify(t)});let O,$;function L(e){let t;return(O??(t=new globalThis.TextEncoder,O=t.encode.bind(t)))(e)}function N(e){let t;return($??(t=new globalThis.TextDecoder,$=t.decode.bind(t)))(e)}var D,U;class q{constructor(){D.set(this,void 0),U.set(this,void 0),t(this,D,new Uint8Array,"f"),t(this,U,null,"f")}decode(e){if(null==e)return[];const r=e instanceof ArrayBuffer?new Uint8Array(e):"string"==typeof e?L(e):e;t(this,D,function(e){let t=0;for(const s of e)t+=s.length;const s=new Uint8Array(t);let r=0;for(const t of e)s.set(t,r),r+=t.length;return s}([s(this,D,"f"),r]),"f");const n=[];let a;for(;null!=(a=j(s(this,D,"f"),s(this,U,"f")));){if(a.carriage&&null==s(this,U,"f")){t(this,U,a.index,"f");continue}if(null!=s(this,U,"f")&&(a.index!==s(this,U,"f")+1||a.carriage)){n.push(N(s(this,D,"f").subarray(0,s(this,U,"f")-1))),t(this,D,s(this,D,"f").subarray(s(this,U,"f")),"f"),t(this,U,null,"f");continue}const e=null!==s(this,U,"f")?a.preceding-1:a.preceding,r=N(s(this,D,"f").subarray(0,e));n.push(r),t(this,D,s(this,D,"f").subarray(a.index),"f"),t(this,U,null,"f")}return n}flush(){return s(this,D,"f").length?this.decode("\n"):[]}}function j(e,t){for(let s=t??0;s<e.length;s++){if(10===e[s])return{preceding:s,index:s+1,carriage:!1};if(13===e[s])return{preceding:s,index:s+1,carriage:!0}}return null}function F(e){for(let t=0;t<e.length-1;t++){if(10===e[t]&&10===e[t+1])return t+2;if(13===e[t]&&13===e[t+1])return t+2;if(13===e[t]&&10===e[t+1]&&t+3<e.length&&13===e[t+2]&&10===e[t+3])return t+4}return-1}D=new WeakMap,U=new WeakMap,q.NEWLINE_CHARS=new Set(["\n","\r"]),q.NEWLINE_REGEXP=/\r\n|[\n\r]/g;const W={off:0,error:200,warn:300,info:400,debug:500},B=(e,t,s)=>{var r,n;if(e)return r=W,n=e,Object.prototype.hasOwnProperty.call(r,n)?e:void V(s).warn(`${t} was set to ${JSON.stringify(e)}, expected one of ${JSON.stringify(Object.keys(W))}`)};function J(){}function z(e,t,s){return!t||W[e]>W[s]?J:t[e].bind(t)}const H={error:J,warn:J,info:J,debug:J};let K=new WeakMap;function V(e){const t=e.logger,s=e.logLevel??"off";if(!t)return H;const r=K.get(t);if(r&&r[0]===s)return r[1];const n={error:z("error",t,s),warn:z("warn",t,s),info:z("info",t,s),debug:z("debug",t,s)};return K.set(t,[s,n]),n}const X=e=>(e.options&&(e.options={...e.options},delete e.options.headers),e.headers&&(e.headers=Object.fromEntries((e.headers instanceof Headers?[...e.headers]:Object.entries(e.headers)).map(([e,t])=>[e,"x-api-key"===e.toLowerCase()||"authorization"===e.toLowerCase()||"cookie"===e.toLowerCase()||"set-cookie"===e.toLowerCase()?"***":t]))),"retryOfRequestLogID"in e&&(e.retryOfRequestLogID&&(e.retryOf=e.retryOfRequestLogID),delete e.retryOfRequestLogID),e);var G,Y,Q;class Z{constructor(e,s,r){this.iterator=e,G.set(this,void 0),this.controller=s,t(this,G,r,"f")}static fromSSEResponse(e,t,s){let r=!1;const a=s?V(s):console;return new Z(async function*(){if(r)throw new o("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");r=!0;let s=!1;try{for await(const s of async function*(e,t){if(!e.body){if(t.abort(),void 0!==globalThis.navigator&&"ReactNative"===globalThis.navigator.product)throw new o("The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api");throw new o("Attempted to iterate over a response with no body")}const s=new ee,r=new q,n=C(e.body);for await(const e of async function*(e){let t=new Uint8Array;for await(const s of e){if(null==s)continue;const e=s instanceof ArrayBuffer?new Uint8Array(s):"string"==typeof s?L(s):s;let r,n=new Uint8Array(t.length+e.length);for(n.set(t),n.set(e,t.length),t=n;-1!==(r=F(t));)yield t.slice(0,r),t=t.slice(r)}t.length>0&&(yield t)}(n))for(const t of r.decode(e)){const e=s.decode(t);e&&(yield e)}for(const e of r.flush()){const t=s.decode(e);t&&(yield t)}}(e,t)){if("completion"===s.event)try{yield JSON.parse(s.data)}catch(e){throw a.error("Could not parse message into JSON:",s.data),a.error("From chunk:",s.raw),e}if("message_start"===s.event||"message_delta"===s.event||"message_stop"===s.event||"content_block_start"===s.event||"content_block_delta"===s.event||"content_block_stop"===s.event)try{yield JSON.parse(s.data)}catch(e){throw a.error("Could not parse message into JSON:",s.data),a.error("From chunk:",s.raw),e}if("ping"!==s.event&&"error"===s.event)throw new i(void 0,S(s.data)??s.data,void 0,e.headers)}s=!0}catch(e){if(n(e))return;throw e}finally{s||t.abort()}},t,s)}static fromReadableStream(e,t,s){let r=!1;return new Z(async function*(){if(r)throw new o("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");r=!0;let s=!1;try{for await(const t of async function*(){const t=new q,s=C(e);for await(const e of s)for(const s of t.decode(e))yield s;for(const e of t.flush())yield e}())s||t&&(yield JSON.parse(t));s=!0}catch(e){if(n(e))return;throw e}finally{s||t.abort()}},t,s)}[(G=new WeakMap,Symbol.asyncIterator)](){return this.iterator()}tee(){const e=[],t=[],r=this.iterator(),n=s=>({next:()=>{if(0===s.length){const s=r.next();e.push(s),t.push(s)}return s.shift()}});return[new Z(()=>n(e),this.controller,s(this,G,"f")),new Z(()=>n(t),this.controller,s(this,G,"f"))]}toReadableStream(){const e=this;let t;return T({async start(){t=e[Symbol.asyncIterator]()},async pull(e){try{const{value:s,done:r}=await t.next();if(r)return e.close();const n=L(JSON.stringify(s)+"\n");e.enqueue(n)}catch(t){e.error(t)}},async cancel(){await(t.return?.())}})}}class ee{constructor(){this.event=null,this.data=[],this.chunks=[]}decode(e){if(e.endsWith("\r")&&(e=e.substring(0,e.length-1)),!e){if(!this.event&&!this.data.length)return null;const e={event:this.event,data:this.data.join("\n"),raw:this.chunks};return this.event=null,this.data=[],this.chunks=[],e}if(this.chunks.push(e),e.startsWith(":"))return null;let[t,s,r]=function(e){const t=e.indexOf(":");return-1!==t?[e.substring(0,t),":",e.substring(t+1)]:[e,"",""]}(e);return r.startsWith(" ")&&(r=r.substring(1)),"event"===t?this.event=r:"data"===t&&this.data.push(r),null}}async function te(e,t){const{response:s,requestLogID:r,retryOfRequestLogID:n,startTime:a}=t,o=await(async()=>{if(t.options.stream)return V(e).debug("response",s.status,s.url,s.headers,s.body),t.options.__streamClass?t.options.__streamClass.fromSSEResponse(s,t.controller):Z.fromSSEResponse(s,t.controller);if(204===s.status)return null;if(t.options.__binaryResponse)return s;const r=s.headers.get("content-type"),n=r?.split(";")[0]?.trim();return n?.includes("application/json")||n?.endsWith("+json")?se(await s.json(),s):await s.text()})();return V(e).debug(`[${r}] response parsed`,X({retryOfRequestLogID:n,url:s.url,status:s.status,body:o,durationMs:Date.now()-a})),o}function se(e,t){return!e||"object"!=typeof e||Array.isArray(e)?e:Object.defineProperty(e,"_request_id",{value:t.headers.get("request-id"),enumerable:!1})}class re extends Promise{constructor(e,s,r=te){super(e=>{e(null)}),this.responsePromise=s,this.parseResponse=r,Y.set(this,void 0),t(this,Y,e,"f")}_thenUnwrap(e){return new re(s(this,Y,"f"),this.responsePromise,async(t,s)=>se(e(await this.parseResponse(t,s),s),s.response))}asResponse(){return this.responsePromise.then(e=>e.response)}async withResponse(){const[e,t]=await Promise.all([this.parse(),this.asResponse()]);return{data:e,response:t,request_id:t.headers.get("request-id")}}parse(){return this.parsedPromise||(this.parsedPromise=this.responsePromise.then(e=>this.parseResponse(s(this,Y,"f"),e))),this.parsedPromise}then(e,t){return this.parse().then(e,t)}catch(e){return this.parse().catch(e)}finally(e){return this.parse().finally(e)}}Y=new WeakMap;class ne{constructor(e,s,r,n){Q.set(this,void 0),t(this,Q,e,"f"),this.options=n,this.response=s,this.body=r}hasNextPage(){return!!this.getPaginatedItems().length&&null!=this.nextPageRequestOptions()}async getNextPage(){const e=this.nextPageRequestOptions();if(!e)throw new o("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.");return await s(this,Q,"f").requestAPIList(this.constructor,e)}async*iterPages(){let e=this;for(yield e;e.hasNextPage();)e=await e.getNextPage(),yield e}async*[(Q=new WeakMap,Symbol.asyncIterator)](){for await(const e of this.iterPages())for(const t of e.getPaginatedItems())yield t}}class ae extends re{constructor(e,t,s){super(e,t,async(e,t)=>new s(e,t.response,await te(e,t),t.options))}async*[Symbol.asyncIterator](){const e=await(this);for await(const t of e)yield t}}class oe extends ne{constructor(e,t,s,r){super(e,t,s,r),this.data=s.data||[],this.has_more=s.has_more||!1,this.first_id=s.first_id||null,this.last_id=s.last_id||null}getPaginatedItems(){return this.data??[]}hasNextPage(){return!1!==this.has_more&&super.hasNextPage()}nextPageRequestOptions(){if(this.options.query?.before_id){const e=this.first_id;return e?{...this.options,query:{...k(this.options.query),before_id:e}}:null}const e=this.last_id;return e?{...this.options,query:{...k(this.options.query),after_id:e}}:null}}class ie extends ne{constructor(e,t,s,r){super(e,t,s,r),this.data=s.data||[],this.has_more=s.has_more||!1,this.next_page=s.next_page||null}getPaginatedItems(){return this.data??[]}hasNextPage(){return!1!==this.has_more&&super.hasNextPage()}nextPageRequestOptions(){const e=this.next_page;return e?{...this.options,query:{...k(this.options.query),page:e}}:null}}const ce=()=>{if("undefined"==typeof File){const{process:e}=globalThis,t="string"==typeof e?.versions?.node&&parseInt(e.versions.node.split("."))<20;throw new Error("`File` is not defined as a global, which is required for file uploads."+(t?" Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`.":""))}};function le(e,t,s){return ce(),new File(e,t??"unknown_file",s)}function de(e){return("object"==typeof e&&null!==e&&("name"in e&&e.name&&String(e.name)||"url"in e&&e.url&&String(e.url)||"filename"in e&&e.filename&&String(e.filename)||"path"in e&&e.path&&String(e.path))||"").split(/[\\/]/).pop()||void 0}const he=e=>null!=e&&"object"==typeof e&&"function"==typeof e[Symbol.asyncIterator],ue=async(e,t)=>({...e,body:await fe(e.body,t)}),pe=new WeakMap,fe=async(e,t)=>{if(!await function(e){const t="function"==typeof e?e:e.fetch,s=pe.get(t);if(s)return s;const r=(async()=>{try{const e="Response"in t?t.Response:(await t("data:,")).constructor,s=new FormData;return s.toString()!==await new e(s).text()}catch{return!0}})();return pe.set(t,r),r}(t))throw new TypeError("The provided fetch function does not support file uploads with the current global FormData class.");const s=new FormData;return await Promise.all(Object.entries(e||{}).map(([e,t])=>me(s,e,t))),s},me=async(e,t,s)=>{if(void 0!==s){if(null==s)throw new TypeError(`Received null for "${t}"; to pass null in FormData, you must use the string 'null'`);if("string"==typeof s||"number"==typeof s||"boolean"==typeof s)e.append(t,String(s));else if(s instanceof Response){let r={};const n=s.headers.get("Content-Type");n&&(r={type:n}),e.append(t,le([await s.blob()],de(s),r))}else if(he(s))e.append(t,le([await new Response(A(s)).blob()],de(s)));else if((e=>e instanceof Blob&&"name"in e)(s))e.append(t,le([s],de(s),{type:s.type}));else if(Array.isArray(s))await Promise.all(s.map(s=>me(e,t+"[]",s)));else{if("object"!=typeof s)throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${s} instead`);await Promise.all(Object.entries(s).map(([s,r])=>me(e,`${t}[${s}]`,r)))}}},ge=e=>null!=e&&"object"==typeof e&&"number"==typeof e.size&&"string"==typeof e.type&&"function"==typeof e.text&&"function"==typeof e.slice&&"function"==typeof e.arrayBuffer;async function we(e){let t=[];if("string"==typeof e||ArrayBuffer.isView(e)||e instanceof ArrayBuffer)t.push(e);else if(ge(e))t.push(e instanceof Blob?e:await e.arrayBuffer());else{if(!he(e)){const t=e?.constructor?.name;throw new Error(`Unexpected data type: ${typeof e}${t?`; constructor: ${t}`:""}${function(e){if("object"!=typeof e||null===e)return"";return`; props: [${Object.getOwnPropertyNames(e).map(e=>`"${e}"`).join(", ")}]`}(e)}`)}for await(const s of e)t.push(...await we(s))}return t}class ye{constructor(e){this._client=e}}const be=Symbol.for("brand.privateNullableHeaders");function*ve(e){if(!e)return;if(be in e){const{values:t,nulls:s}=e;yield*t.entries();for(const e of s)yield[e,null];return}let t,s=!1;e instanceof Headers?t=e.entries():_(e)?t=e:(s=!0,t=Object.entries(e??{}));for(let e of t){const t=e[0];if("string"!=typeof t)throw new TypeError("expected header name to be a string");const r=_(e[1])?e[1]:[e[1]];let n=!1;for(const e of r)void 0!==e&&(s&&!n&&(n=!0,yield[t,null]),yield[t,e])}}const _e=e=>{const t=new Headers,s=new Set;for(const r of e){const e=new Set;for(const[n,a]of ve(r)){const r=n.toLowerCase();e.has(r)||(t.delete(n),e.add(r)),null===a?(t.delete(n),s.add(r)):(t.append(n,a),s.delete(r))}}return{[be]:!0,values:t,nulls:s}};function ke(e){return e.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g,encodeURIComponent)}const Se=Object.freeze(Object.create(null)),Me=(e=ke)=>function(t,...s){if(1===t.length)return t[0];let r=!1;const n=[],a=t.reduce((t,a,o)=>{/[?#]/.test(a)&&(r=!0);const i=s[o];let c=(r?encodeURIComponent:e)(""+i);return o!==s.length&&(null==i||"object"==typeof i&&i.toString===Object.getPrototypeOf(Object.getPrototypeOf(i.hasOwnProperty??Se)??Se)?.toString)&&(c=i+"",n.push({start:t.length+a.length,length:c.length,error:`Value of type ${Object.prototype.toString.call(i).slice(8,-1)} is not a valid path parameter`})),t+a+(o===s.length?"":c)},""),i=a.split(/[?#]/,1)[0],c=/(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;let l;for(;null!==(l=c.exec(i));)n.push({start:l.index,length:l[0].length,error:`Value "${l[0]}" can't be safely passed as a path parameter`});if(n.sort((e,t)=>e.start-t.start),n.length>0){let e=0;const t=n.reduce((t,s)=>{const r=" ".repeat(s.start-e),n="^".repeat(s.length);return e=s.start+s.length,t+r+n},"");throw new o(`Path parameters result in path with invalid segments:\n${n.map(e=>e.error).join("\n")}\n${a}\n${t}`)}return a},Pe=Me(ke);class Ee extends ye{list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/files",oe,{query:r,...t,headers:_e([{"anthropic-beta":[...s??[],"files-api-2025-04-14"].toString()},t?.headers])})}delete(e,t={},s){const{betas:r}=t??{};return this._client.delete(Pe`/v1/files/${e}`,{...s,headers:_e([{"anthropic-beta":[...r??[],"files-api-2025-04-14"].toString()},s?.headers])})}download(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/files/${e}/content`,{...s,headers:_e([{"anthropic-beta":[...r??[],"files-api-2025-04-14"].toString(),Accept:"application/binary"},s?.headers]),__binaryResponse:!0})}retrieveMetadata(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/files/${e}`,{...s,headers:_e([{"anthropic-beta":[...r??[],"files-api-2025-04-14"].toString()},s?.headers])})}upload(e,t){const{betas:s,...r}=e;return this._client.post("/v1/files",ue({body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"files-api-2025-04-14"].toString()},t?.headers])},this._client))}}class Re extends ye{retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/models/${e}?beta=true`,{...s,headers:_e([{...null!=r?.toString()?{"anthropic-beta":r?.toString()}:void 0},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/models?beta=true",oe,{query:r,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers])})}}const xe={"claude-opus-4-20250514":8192,"claude-opus-4-0":8192,"claude-4-opus-20250514":8192,"anthropic.claude-opus-4-20250514-v1:0":8192,"claude-opus-4@20250514":8192,"claude-opus-4-1-20250805":8192,"anthropic.claude-opus-4-1-20250805-v1:0":8192,"claude-opus-4-1@20250805":8192};function Te(e,t){return t&&"parse"in(t.output_format??{})?Ae(e,t):{...e,content:e.content.map(e=>"text"===e.type?{...e,parsed:null}:e),parsed_output:null}}function Ae(e,t){let s=null;const r=e.content.map(e=>{if("text"===e.type){const r=function(e,t){if("json_schema"!==e.output_format?.type)return null;try{return"parse"in e.output_format?e.output_format.parse(t):JSON.parse(t)}catch(e){throw new o(`Failed to parse structured output: ${e}`)}}(t,e.text);return null===s&&(s=r),{...e,parsed:r}}return e});return{...e,content:r,parsed_output:s}}const Ce=e=>{if(0===e.length)return e;let t=e[e.length-1];switch(t.type){case"separator":return e=e.slice(0,e.length-1),Ce(e);case"number":let s=t.value[t.value.length-1];if("."===s||"-"===s)return e=e.slice(0,e.length-1),Ce(e);case"string":let r=e[e.length-2];if("delimiter"===r?.type)return e=e.slice(0,e.length-1),Ce(e);if("brace"===r?.type&&"{"===r.value)return e=e.slice(0,e.length-1),Ce(e);break;case"delimiter":return e=e.slice(0,e.length-1),Ce(e)}return e},Ie=e=>JSON.parse((e=>{let t="";return e.map(e=>{"string"===e.type?t+='"'+e.value+'"':t+=e.value}),t})((e=>{let t=[];return e.map(e=>{"brace"===e.type&&("{"===e.value?t.push("}"):t.splice(t.lastIndexOf("}"),1)),"paren"===e.type&&("["===e.value?t.push("]"):t.splice(t.lastIndexOf("]"),1))}),t.length>0&&t.reverse().map(t=>{"}"===t?e.push({type:"brace",value:"}"}):"]"===t&&e.push({type:"paren",value:"]"})}),e})(Ce((e=>{let t=0,s=[];for(;t<e.length;){let r=e[t];if("\\"===r){t++;continue}if("{"===r){s.push({type:"brace",value:"{"}),t++;continue}if("}"===r){s.push({type:"brace",value:"}"}),t++;continue}if("["===r){s.push({type:"paren",value:"["}),t++;continue}if("]"===r){s.push({type:"paren",value:"]"}),t++;continue}if(":"===r){s.push({type:"separator",value:":"}),t++;continue}if(","===r){s.push({type:"delimiter",value:","}),t++;continue}if('"'===r){let n="",a=!1;for(r=e[++t];'"'!==r;){if(t===e.length){a=!0;break}if("\\"===r){if(t++,t===e.length){a=!0;break}n+=r+e[t],r=e[++t]}else n+=r,r=e[++t]}r=e[++t],a||s.push({type:"string",value:n});continue}if(r&&/\s/.test(r)){t++;continue}let n=/[0-9]/;if(r&&n.test(r)||"-"===r||"."===r){let a="";for("-"===r&&(a+=r,r=e[++t]);r&&n.test(r)||"."===r;)a+=r,r=e[++t];s.push({type:"number",value:a});continue}let a=/[a-z]/i;if(r&&a.test(r)){let n="";for(;r&&a.test(r)&&t!==e.length;)n+=r,r=e[++t];if("true"!=n&&"false"!=n&&"null"!==n){t++;continue}s.push({type:"name",value:n});continue}t++}return s})(e)))));var Oe,$e,Le,Ne,De,Ue,qe,je,Fe,We,Be,Je,ze,He,Ke,Ve,Xe,Ge,Ye,Qe,Ze,et,tt;const st="__json_buf";function rt(e){return"tool_use"===e.type||"server_tool_use"===e.type||"mcp_tool_use"===e.type}class nt{constructor(e){Oe.add(this),this.messages=[],this.receivedMessages=[],$e.set(this,void 0),Le.set(this,null),this.controller=new AbortController,Ne.set(this,void 0),De.set(this,()=>{}),Ue.set(this,()=>{}),qe.set(this,void 0),je.set(this,()=>{}),Fe.set(this,()=>{}),We.set(this,{}),Be.set(this,!1),Je.set(this,!1),ze.set(this,!1),He.set(this,!1),Ke.set(this,void 0),Ve.set(this,void 0),Ye.set(this,e=>{if(t(this,Je,!0,"f"),n(e)&&(e=new c),e instanceof c)return t(this,ze,!0,"f"),this._emit("abort",e);if(e instanceof o)return this._emit("error",e);if(e instanceof Error){const t=new o(e.message);return t.cause=e,this._emit("error",t)}return this._emit("error",new o(String(e)))}),t(this,Ne,new Promise((e,s)=>{t(this,De,e,"f"),t(this,Ue,s,"f")}),"f"),t(this,qe,new Promise((e,s)=>{t(this,je,e,"f"),t(this,Fe,s,"f")}),"f"),s(this,Ne,"f").catch(()=>{}),s(this,qe,"f").catch(()=>{}),t(this,Le,e,"f")}get response(){return s(this,Ke,"f")}get request_id(){return s(this,Ve,"f")}async withResponse(){const e=await s(this,Ne,"f");if(!e)throw new Error("Could not resolve a `Response` object");return{data:this,response:e,request_id:e.headers.get("request-id")}}static fromReadableStream(e){const t=new nt(null);return t._run(()=>t._fromReadableStream(e)),t}static createMessage(e,s,r){const n=new nt(s);for(const e of s.messages)n._addMessageParam(e);return t(n,Le,{...s,stream:!0},"f"),n._run(()=>n._createMessage(e,{...s,stream:!0},{...r,headers:{...r?.headers,"X-Stainless-Helper-Method":"stream"}})),n}_run(e){e().then(()=>{this._emitFinal(),this._emit("end")},s(this,Ye,"f"))}_addMessageParam(e){this.messages.push(e)}_addMessage(e,t=!0){this.receivedMessages.push(e),t&&this._emit("message",e)}async _createMessage(e,t,r){const n=r?.signal;let a;n&&(n.aborted&&this.controller.abort(),a=this.controller.abort.bind(this.controller),n.addEventListener("abort",a));try{s(this,Oe,"m",Qe).call(this);const{response:n,data:a}=await e.create({...t,stream:!0},{...r,signal:this.controller.signal}).withResponse();this._connected(n);for await(const e of a)s(this,Oe,"m",Ze).call(this,e);if(a.controller.signal?.aborted)throw new c;s(this,Oe,"m",et).call(this)}finally{n&&a&&n.removeEventListener("abort",a)}}_connected(e){this.ended||(t(this,Ke,e,"f"),t(this,Ve,e?.headers.get("request-id"),"f"),s(this,De,"f").call(this,e),this._emit("connect"))}get ended(){return s(this,Be,"f")}get errored(){return s(this,Je,"f")}get aborted(){return s(this,ze,"f")}abort(){this.controller.abort()}on(e,t){return(s(this,We,"f")[e]||(s(this,We,"f")[e]=[])).push({listener:t}),this}off(e,t){const r=s(this,We,"f")[e];if(!r)return this;const n=r.findIndex(e=>e.listener===t);return n>=0&&r.splice(n,1),this}once(e,t){return(s(this,We,"f")[e]||(s(this,We,"f")[e]=[])).push({listener:t,once:!0}),this}emitted(e){return new Promise((s,r)=>{t(this,He,!0,"f"),"error"!==e&&this.once("error",r),this.once(e,s)})}async done(){t(this,He,!0,"f"),await s(this,qe,"f")}get currentMessage(){return s(this,$e,"f")}async finalMessage(){return await this.done(),s(this,Oe,"m",Xe).call(this)}async finalText(){return await this.done(),s(this,Oe,"m",Ge).call(this)}_emit(e,...r){if(s(this,Be,"f"))return;"end"===e&&(t(this,Be,!0,"f"),s(this,je,"f").call(this));const n=s(this,We,"f")[e];if(n&&(s(this,We,"f")[e]=n.filter(e=>!e.once),n.forEach(({listener:e})=>e(...r))),"abort"===e){const e=r[0];return s(this,He,"f")||n?.length||Promise.reject(e),s(this,Ue,"f").call(this,e),s(this,Fe,"f").call(this,e),void this._emit("end")}if("error"===e){const e=r[0];s(this,He,"f")||n?.length||Promise.reject(e),s(this,Ue,"f").call(this,e),s(this,Fe,"f").call(this,e),this._emit("end")}}_emitFinal(){this.receivedMessages.at(-1)&&this._emit("finalMessage",s(this,Oe,"m",Xe).call(this))}async _fromReadableStream(e,t){const r=t?.signal;let n;r&&(r.aborted&&this.controller.abort(),n=this.controller.abort.bind(this.controller),r.addEventListener("abort",n));try{s(this,Oe,"m",Qe).call(this),this._connected(null);const t=Z.fromReadableStream(e,this.controller);for await(const e of t)s(this,Oe,"m",Ze).call(this,e);if(t.controller.signal?.aborted)throw new c;s(this,Oe,"m",et).call(this)}finally{r&&n&&r.removeEventListener("abort",n)}}[($e=new WeakMap,Le=new WeakMap,Ne=new WeakMap,De=new WeakMap,Ue=new WeakMap,qe=new WeakMap,je=new WeakMap,Fe=new WeakMap,We=new WeakMap,Be=new WeakMap,Je=new WeakMap,ze=new WeakMap,He=new WeakMap,Ke=new WeakMap,Ve=new WeakMap,Ye=new WeakMap,Oe=new WeakSet,Xe=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");return this.receivedMessages.at(-1)},Ge=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");const e=this.receivedMessages.at(-1).content.filter(e=>"text"===e.type).map(e=>e.text);if(0===e.length)throw new o("stream ended without producing a content block with type=text");return e.join(" ")},Qe=function(){this.ended||t(this,$e,void 0,"f")},Ze=function(e){if(this.ended)return;const r=s(this,Oe,"m",tt).call(this,e);switch(this._emit("streamEvent",e,r),e.type){case"content_block_delta":{const t=r.content.at(-1);switch(e.delta.type){case"text_delta":"text"===t.type&&this._emit("text",e.delta.text,t.text||"");break;case"citations_delta":"text"===t.type&&this._emit("citation",e.delta.citation,t.citations??[]);break;case"input_json_delta":rt(t)&&t.input&&this._emit("inputJson",e.delta.partial_json,t.input);break;case"thinking_delta":"thinking"===t.type&&this._emit("thinking",e.delta.thinking,t.thinking);break;case"signature_delta":"thinking"===t.type&&this._emit("signature",t.signature);break;default:e.delta}break}case"message_stop":this._addMessageParam(r),this._addMessage(Te(r,s(this,Le,"f")),!0);break;case"content_block_stop":this._emit("contentBlock",r.content.at(-1));break;case"message_start":t(this,$e,r,"f")}},et=function(){if(this.ended)throw new o("stream has ended, this shouldn't happen");const e=s(this,$e,"f");if(!e)throw new o("request ended without sending any chunks");return t(this,$e,void 0,"f"),Te(e,s(this,Le,"f"))},tt=function(e){let t=s(this,$e,"f");if("message_start"===e.type){if(t)throw new o(`Unexpected event order, got ${e.type} before receiving "message_stop"`);return e.message}if(!t)throw new o(`Unexpected event order, got ${e.type} before "message_start"`);switch(e.type){case"message_stop":case"content_block_stop":return t;case"message_delta":return t.container=e.delta.container,t.stop_reason=e.delta.stop_reason,t.stop_sequence=e.delta.stop_sequence,t.usage.output_tokens=e.usage.output_tokens,t.context_management=e.context_management,null!=e.usage.input_tokens&&(t.usage.input_tokens=e.usage.input_tokens),null!=e.usage.cache_creation_input_tokens&&(t.usage.cache_creation_input_tokens=e.usage.cache_creation_input_tokens),null!=e.usage.cache_read_input_tokens&&(t.usage.cache_read_input_tokens=e.usage.cache_read_input_tokens),null!=e.usage.server_tool_use&&(t.usage.server_tool_use=e.usage.server_tool_use),t;case"content_block_start":return t.content.push(e.content_block),t;case"content_block_delta":{const r=t.content.at(e.index);switch(e.delta.type){case"text_delta":"text"===r?.type&&(t.content[e.index]={...r,text:(r.text||"")+e.delta.text});break;case"citations_delta":"text"===r?.type&&(t.content[e.index]={...r,citations:[...r.citations??[],e.delta.citation]});break;case"input_json_delta":if(r&&rt(r)){let n=r[st]||"";n+=e.delta.partial_json;const a={...r};if(Object.defineProperty(a,st,{value:n,enumerable:!1,writable:!0}),n)try{a.input=Ie(n)}catch(e){const t=new o(`Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${e}. JSON: ${n}`);s(this,Ye,"f").call(this,t)}t.content[e.index]=a}break;case"thinking_delta":"thinking"===r?.type&&(t.content[e.index]={...r,thinking:r.thinking+e.delta.thinking});break;case"signature_delta":"thinking"===r?.type&&(t.content[e.index]={...r,signature:e.delta.signature});break;default:e.delta}return t}}},Symbol.asyncIterator)](){const e=[],t=[];let s=!1;return this.on("streamEvent",s=>{const r=t.shift();r?r.resolve(s):e.push(s)}),this.on("end",()=>{s=!0;for(const e of t)e.resolve(void 0);t.length=0}),this.on("abort",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),this.on("error",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),{next:async()=>e.length?{value:e.shift(),done:!1}:s?{value:void 0,done:!0}:new Promise((e,s)=>t.push({resolve:e,reject:s})).then(e=>e?{value:e,done:!1}:{value:void 0,done:!0}),return:async()=>(this.abort(),{value:void 0,done:!0})}}toReadableStream(){return new Z(this[Symbol.asyncIterator].bind(this),this.controller).toReadableStream()}}var at,ot,it,ct,lt,dt,ht,ut,pt,ft,mt;function gt(){let e,t;return{promise:new Promise((s,r)=>{e=s,t=r}),resolve:e,reject:t}}class wt{constructor(e,s,r){at.add(this),this.client=e,ot.set(this,!1),it.set(this,!1),ct.set(this,void 0),lt.set(this,void 0),dt.set(this,void 0),ht.set(this,void 0),ut.set(this,void 0),pt.set(this,0),t(this,ct,{params:{...s,messages:structuredClone(s.messages)}},"f"),t(this,lt,{...r,headers:_e([{"x-stainless-helper":"BetaToolRunner"},r?.headers])},"f"),t(this,ut,gt(),"f")}async*[(ot=new WeakMap,it=new WeakMap,ct=new WeakMap,lt=new WeakMap,dt=new WeakMap,ht=new WeakMap,ut=new WeakMap,pt=new WeakMap,at=new WeakSet,ft=async function(){const e=s(this,ct,"f").params.compactionControl;if(!e||!e.enabled)return!1;let t=0;if(void 0!==s(this,dt,"f"))try{const e=await s(this,dt,"f");t=e.usage.input_tokens+(e.usage.cache_creation_input_tokens??0)+(e.usage.cache_read_input_tokens??0)+e.usage.output_tokens}catch{return!1}if(t<(e.contextTokenThreshold??1e5))return!1;const r=e.model??s(this,ct,"f").params.model,n=e.summaryPrompt??"You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:\n1. Task Overview\nThe user's core request and success criteria\nAny clarifications or constraints they specified\n2. Current State\nWhat has been completed so far\nFiles created, modified, or analyzed (with paths if relevant)\nKey outputs or artifacts produced\n3. Important Discoveries\nTechnical constraints or requirements uncovered\nDecisions made and their rationale\nErrors encountered and how they were resolved\nWhat approaches were tried that didn't work (and why)\n4. Next Steps\nSpecific actions needed to complete the task\nAny blockers or open questions to resolve\nPriority order if multiple steps remain\n5. Context to Preserve\nUser preferences or style requirements\nDomain-specific details that aren't obvious\nAny promises made to the user\nBe concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.\nWrap your summary in <summary></summary> tags.",a=s(this,ct,"f").params.messages;if("assistant"===a[a.length-1].role){const e=a[a.length-1];if(Array.isArray(e.content)){const t=e.content.filter(e=>"tool_use"!==e.type);0===t.length?a.pop():e.content=t}}const i=await this.client.beta.messages.create({model:r,messages:[...a,{role:"user",content:[{type:"text",text:n}]}],max_tokens:s(this,ct,"f").params.max_tokens},{headers:{"x-stainless-helper":"compaction"}});if("text"!==i.content[0]?.type)throw new o("Expected text response for compaction");return s(this,ct,"f").params.messages=[{role:"user",content:i.content}],!0},Symbol.asyncIterator)](){var e;if(s(this,ot,"f"))throw new o("Cannot iterate over a consumed stream");t(this,ot,!0,"f"),t(this,it,!0,"f"),t(this,ht,void 0,"f");try{for(;;){let r;try{if(s(this,ct,"f").params.max_iterations&&s(this,pt,"f")>=s(this,ct,"f").params.max_iterations)break;t(this,it,!1,"f"),t(this,ht,void 0,"f"),t(this,pt,(e=s(this,pt,"f"),++e),"f"),t(this,dt,void 0,"f");const{max_iterations:n,compactionControl:a,...o}=s(this,ct,"f").params;if(o.stream?(r=this.client.beta.messages.stream({...o},s(this,lt,"f")),t(this,dt,r.finalMessage(),"f"),s(this,dt,"f").catch(()=>{}),yield r):(t(this,dt,this.client.beta.messages.create({...o,stream:!1},s(this,lt,"f")),"f"),yield s(this,dt,"f")),!await s(this,at,"m",ft).call(this)){if(!s(this,it,"f")){const{role:e,content:t}=await s(this,dt,"f");s(this,ct,"f").params.messages.push({role:e,content:t})}const e=await s(this,at,"m",mt).call(this,s(this,ct,"f").params.messages.at(-1));if(e)s(this,ct,"f").params.messages.push(e);else if(!s(this,it,"f"))break}}finally{r&&r.abort()}}if(!s(this,dt,"f"))throw new o("ToolRunner concluded without a message from the server");s(this,ut,"f").resolve(await s(this,dt,"f"))}catch(e){throw t(this,ot,!1,"f"),s(this,ut,"f").promise.catch(()=>{}),s(this,ut,"f").reject(e),t(this,ut,gt(),"f"),e}}setMessagesParams(e){s(this,ct,"f").params="function"==typeof e?e(s(this,ct,"f").params):e,t(this,it,!0,"f"),t(this,ht,void 0,"f")}async generateToolResponse(){const e=await s(this,dt,"f")??this.params.messages.at(-1);return e?s(this,at,"m",mt).call(this,e):null}done(){return s(this,ut,"f").promise}async runUntilDone(){if(!s(this,ot,"f"))for await(const e of this);return this.done()}get params(){return s(this,ct,"f").params}pushMessages(...e){this.setMessagesParams(t=>({...t,messages:[...t.messages,...e]}))}then(e,t){return this.runUntilDone().then(e,t)}}mt=async function(e){return void 0!==s(this,ht,"f")||t(this,ht,async function(e,t=e.messages.at(-1)){if(!t||"assistant"!==t.role||!t.content||"string"==typeof t.content)return null;const s=t.content.filter(e=>"tool_use"===e.type);return 0===s.length?null:{role:"user",content:await Promise.all(s.map(async t=>{const s=e.tools.find(e=>("name"in e?e.name:e.mcp_server_name)===t.name);if(!s||!("run"in s))return{type:"tool_result",tool_use_id:t.id,content:`Error: Tool '${t.name}' not found`,is_error:!0};try{let e=t.input;"parse"in s&&s.parse&&(e=s.parse(e));const r=await s.run(e);return{type:"tool_result",tool_use_id:t.id,content:r}}catch(e){return{type:"tool_result",tool_use_id:t.id,content:`Error: ${e instanceof Error?e.message:String(e)}`,is_error:!0}}}))}}(s(this,ct,"f").params,e),"f"),s(this,ht,"f")};class yt{constructor(e,t){this.iterator=e,this.controller=t}async*decoder(){const e=new q;for await(const t of this.iterator)for(const s of e.decode(t))yield JSON.parse(s);for(const t of e.flush())yield JSON.parse(t)}[Symbol.asyncIterator](){return this.decoder()}static fromResponse(e,t){if(!e.body){if(t.abort(),void 0!==globalThis.navigator&&"ReactNative"===globalThis.navigator.product)throw new o("The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api");throw new o("Attempted to iterate over a response with no body")}return new yt(C(e.body),t)}}class bt extends ye{create(e,t){const{betas:s,...r}=e;return this._client.post("/v1/messages/batches?beta=true",{body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"message-batches-2024-09-24"].toString()},t?.headers])})}retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/messages/batches/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"message-batches-2024-09-24"].toString()},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/messages/batches?beta=true",oe,{query:r,...t,headers:_e([{"anthropic-beta":[...s??[],"message-batches-2024-09-24"].toString()},t?.headers])})}delete(e,t={},s){const{betas:r}=t??{};return this._client.delete(Pe`/v1/messages/batches/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"message-batches-2024-09-24"].toString()},s?.headers])})}cancel(e,t={},s){const{betas:r}=t??{};return this._client.post(Pe`/v1/messages/batches/${e}/cancel?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"message-batches-2024-09-24"].toString()},s?.headers])})}async results(e,t={},s){const r=await this.retrieve(e);if(!r.results_url)throw new o(`No batch \`results_url\`; Has it finished processing? ${r.processing_status} - ${r.id}`);const{betas:n}=t??{};return this._client.get(r.results_url,{...s,headers:_e([{"anthropic-beta":[...n??[],"message-batches-2024-09-24"].toString(),Accept:"application/binary"},s?.headers]),stream:!0,__binaryResponse:!0})._thenUnwrap((e,t)=>yt.fromResponse(t.response,t.controller))}}const vt={"claude-1.3":"November 6th, 2024","claude-1.3-100k":"November 6th, 2024","claude-instant-1.1":"November 6th, 2024","claude-instant-1.1-100k":"November 6th, 2024","claude-instant-1.2":"November 6th, 2024","claude-3-sonnet-20240229":"July 21st, 2025","claude-3-opus-20240229":"January 5th, 2026","claude-2.1":"July 21st, 2025","claude-2.0":"July 21st, 2025","claude-3-7-sonnet-latest":"February 19th, 2026","claude-3-7-sonnet-20250219":"February 19th, 2026"};class _t extends ye{constructor(){super(...arguments),this.batches=new bt(this._client)}create(e,t){const{betas:s,...r}=e;r.model in vt&&console.warn(`The model '${r.model}' is deprecated and will reach end-of-life on ${vt[r.model]}\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`);let n=this._client._options.timeout;if(!r.stream&&null==n){const e=xe[r.model]??void 0;n=this._client.calculateNonstreamingTimeout(r.max_tokens,e)}return this._client.post("/v1/messages?beta=true",{body:r,timeout:n??6e5,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers]),stream:e.stream??!1})}parse(e,t){return t={...t,headers:_e([{"anthropic-beta":[...e.betas??[],"structured-outputs-2025-11-13"].toString()},t?.headers])},this.create(e,t).then(t=>Ae(t,e))}stream(e,t){return nt.createMessage(this,e,t)}countTokens(e,t){const{betas:s,...r}=e;return this._client.post("/v1/messages/count_tokens?beta=true",{body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"token-counting-2024-11-01"].toString()},t?.headers])})}toolRunner(e,t){return new wt(this._client,e,t)}}_t.Batches=bt,_t.BetaToolRunner=wt;class kt extends ye{create(e,t={},s){const{betas:r,...n}=t??{};return this._client.post(Pe`/v1/skills/${e}/versions?beta=true`,ue({body:n,...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])},this._client))}retrieve(e,t,s){const{skill_id:r,betas:n}=t;return this._client.get(Pe`/v1/skills/${r}/versions/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...n??[],"skills-2025-10-02"].toString()},s?.headers])})}list(e,t={},s){const{betas:r,...n}=t??{};return this._client.getAPIList(Pe`/v1/skills/${e}/versions?beta=true`,ie,{query:n,...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])})}delete(e,t,s){const{skill_id:r,betas:n}=t;return this._client.delete(Pe`/v1/skills/${r}/versions/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...n??[],"skills-2025-10-02"].toString()},s?.headers])})}}class St extends ye{constructor(){super(...arguments),this.versions=new kt(this._client)}create(e={},t){const{betas:s,...r}=e??{};return this._client.post("/v1/skills?beta=true",ue({body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"skills-2025-10-02"].toString()},t?.headers])},this._client))}retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/skills/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/skills?beta=true",ie,{query:r,...t,headers:_e([{"anthropic-beta":[...s??[],"skills-2025-10-02"].toString()},t?.headers])})}delete(e,t={},s){const{betas:r}=t??{};return this._client.delete(Pe`/v1/skills/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])})}}St.Versions=kt;class Mt extends ye{constructor(){super(...arguments),this.models=new Re(this._client),this.messages=new _t(this._client),this.files=new Ee(this._client),this.skills=new St(this._client)}}Mt.Models=Re,Mt.Messages=_t,Mt.Files=Ee,Mt.Skills=St;class Pt extends ye{create(e,t){const{betas:s,...r}=e;return this._client.post("/v1/complete",{body:r,timeout:this._client._options.timeout??6e5,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers]),stream:e.stream??!1})}}var Et,Rt,xt,Tt,At,Ct,It,Ot,$t,Lt,Nt,Dt,Ut,qt,jt,Ft,Wt,Bt,Jt,zt,Ht,Kt;const Vt="__json_buf";function Xt(e){return"tool_use"===e.type||"server_tool_use"===e.type}class Gt{constructor(){Et.add(this),this.messages=[],this.receivedMessages=[],Rt.set(this,void 0),this.controller=new AbortController,xt.set(this,void 0),Tt.set(this,()=>{}),At.set(this,()=>{}),Ct.set(this,void 0),It.set(this,()=>{}),Ot.set(this,()=>{}),$t.set(this,{}),Lt.set(this,!1),Nt.set(this,!1),Dt.set(this,!1),Ut.set(this,!1),qt.set(this,void 0),jt.set(this,void 0),Bt.set(this,e=>{if(t(this,Nt,!0,"f"),n(e)&&(e=new c),e instanceof c)return t(this,Dt,!0,"f"),this._emit("abort",e);if(e instanceof o)return this._emit("error",e);if(e instanceof Error){const t=new o(e.message);return t.cause=e,this._emit("error",t)}return this._emit("error",new o(String(e)))}),t(this,xt,new Promise((e,s)=>{t(this,Tt,e,"f"),t(this,At,s,"f")}),"f"),t(this,Ct,new Promise((e,s)=>{t(this,It,e,"f"),t(this,Ot,s,"f")}),"f"),s(this,xt,"f").catch(()=>{}),s(this,Ct,"f").catch(()=>{})}get response(){return s(this,qt,"f")}get request_id(){return s(this,jt,"f")}async withResponse(){const e=await s(this,xt,"f");if(!e)throw new Error("Could not resolve a `Response` object");return{data:this,response:e,request_id:e.headers.get("request-id")}}static fromReadableStream(e){const t=new Gt;return t._run(()=>t._fromReadableStream(e)),t}static createMessage(e,t,s){const r=new Gt;for(const e of t.messages)r._addMessageParam(e);return r._run(()=>r._createMessage(e,{...t,stream:!0},{...s,headers:{...s?.headers,"X-Stainless-Helper-Method":"stream"}})),r}_run(e){e().then(()=>{this._emitFinal(),this._emit("end")},s(this,Bt,"f"))}_addMessageParam(e){this.messages.push(e)}_addMessage(e,t=!0){this.receivedMessages.push(e),t&&this._emit("message",e)}async _createMessage(e,t,r){const n=r?.signal;let a;n&&(n.aborted&&this.controller.abort(),a=this.controller.abort.bind(this.controller),n.addEventListener("abort",a));try{s(this,Et,"m",Jt).call(this);const{response:n,data:a}=await e.create({...t,stream:!0},{...r,signal:this.controller.signal}).withResponse();this._connected(n);for await(const e of a)s(this,Et,"m",zt).call(this,e);if(a.controller.signal?.aborted)throw new c;s(this,Et,"m",Ht).call(this)}finally{n&&a&&n.removeEventListener("abort",a)}}_connected(e){this.ended||(t(this,qt,e,"f"),t(this,jt,e?.headers.get("request-id"),"f"),s(this,Tt,"f").call(this,e),this._emit("connect"))}get ended(){return s(this,Lt,"f")}get errored(){return s(this,Nt,"f")}get aborted(){return s(this,Dt,"f")}abort(){this.controller.abort()}on(e,t){return(s(this,$t,"f")[e]||(s(this,$t,"f")[e]=[])).push({listener:t}),this}off(e,t){const r=s(this,$t,"f")[e];if(!r)return this;const n=r.findIndex(e=>e.listener===t);return n>=0&&r.splice(n,1),this}once(e,t){return(s(this,$t,"f")[e]||(s(this,$t,"f")[e]=[])).push({listener:t,once:!0}),this}emitted(e){return new Promise((s,r)=>{t(this,Ut,!0,"f"),"error"!==e&&this.once("error",r),this.once(e,s)})}async done(){t(this,Ut,!0,"f"),await s(this,Ct,"f")}get currentMessage(){return s(this,Rt,"f")}async finalMessage(){return await this.done(),s(this,Et,"m",Ft).call(this)}async finalText(){return await this.done(),s(this,Et,"m",Wt).call(this)}_emit(e,...r){if(s(this,Lt,"f"))return;"end"===e&&(t(this,Lt,!0,"f"),s(this,It,"f").call(this));const n=s(this,$t,"f")[e];if(n&&(s(this,$t,"f")[e]=n.filter(e=>!e.once),n.forEach(({listener:e})=>e(...r))),"abort"===e){const e=r[0];return s(this,Ut,"f")||n?.length||Promise.reject(e),s(this,At,"f").call(this,e),s(this,Ot,"f").call(this,e),void this._emit("end")}if("error"===e){const e=r[0];s(this,Ut,"f")||n?.length||Promise.reject(e),s(this,At,"f").call(this,e),s(this,Ot,"f").call(this,e),this._emit("end")}}_emitFinal(){this.receivedMessages.at(-1)&&this._emit("finalMessage",s(this,Et,"m",Ft).call(this))}async _fromReadableStream(e,t){const r=t?.signal;let n;r&&(r.aborted&&this.controller.abort(),n=this.controller.abort.bind(this.controller),r.addEventListener("abort",n));try{s(this,Et,"m",Jt).call(this),this._connected(null);const t=Z.fromReadableStream(e,this.controller);for await(const e of t)s(this,Et,"m",zt).call(this,e);if(t.controller.signal?.aborted)throw new c;s(this,Et,"m",Ht).call(this)}finally{r&&n&&r.removeEventListener("abort",n)}}[(Rt=new WeakMap,xt=new WeakMap,Tt=new WeakMap,At=new WeakMap,Ct=new WeakMap,It=new WeakMap,Ot=new WeakMap,$t=new WeakMap,Lt=new WeakMap,Nt=new WeakMap,Dt=new WeakMap,Ut=new WeakMap,qt=new WeakMap,jt=new WeakMap,Bt=new WeakMap,Et=new WeakSet,Ft=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");return this.receivedMessages.at(-1)},Wt=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");const e=this.receivedMessages.at(-1).content.filter(e=>"text"===e.type).map(e=>e.text);if(0===e.length)throw new o("stream ended without producing a content block with type=text");return e.join(" ")},Jt=function(){this.ended||t(this,Rt,void 0,"f")},zt=function(e){if(this.ended)return;const r=s(this,Et,"m",Kt).call(this,e);switch(this._emit("streamEvent",e,r),e.type){case"content_block_delta":{const t=r.content.at(-1);switch(e.delta.type){case"text_delta":"text"===t.type&&this._emit("text",e.delta.text,t.text||"");break;case"citations_delta":"text"===t.type&&this._emit("citation",e.delta.citation,t.citations??[]);break;case"input_json_delta":Xt(t)&&t.input&&this._emit("inputJson",e.delta.partial_json,t.input);break;case"thinking_delta":"thinking"===t.type&&this._emit("thinking",e.delta.thinking,t.thinking);break;case"signature_delta":"thinking"===t.type&&this._emit("signature",t.signature);break;default:e.delta}break}case"message_stop":this._addMessageParam(r),this._addMessage(r,!0);break;case"content_block_stop":this._emit("contentBlock",r.content.at(-1));break;case"message_start":t(this,Rt,r,"f")}},Ht=function(){if(this.ended)throw new o("stream has ended, this shouldn't happen");const e=s(this,Rt,"f");if(!e)throw new o("request ended without sending any chunks");return t(this,Rt,void 0,"f"),e},Kt=function(e){let t=s(this,Rt,"f");if("message_start"===e.type){if(t)throw new o(`Unexpected event order, got ${e.type} before receiving "message_stop"`);return e.message}if(!t)throw new o(`Unexpected event order, got ${e.type} before "message_start"`);switch(e.type){case"message_stop":case"content_block_stop":return t;case"message_delta":return t.stop_reason=e.delta.stop_reason,t.stop_sequence=e.delta.stop_sequence,t.usage.output_tokens=e.usage.output_tokens,null!=e.usage.input_tokens&&(t.usage.input_tokens=e.usage.input_tokens),null!=e.usage.cache_creation_input_tokens&&(t.usage.cache_creation_input_tokens=e.usage.cache_creation_input_tokens),null!=e.usage.cache_read_input_tokens&&(t.usage.cache_read_input_tokens=e.usage.cache_read_input_tokens),null!=e.usage.server_tool_use&&(t.usage.server_tool_use=e.usage.server_tool_use),t;case"content_block_start":return t.content.push({...e.content_block}),t;case"content_block_delta":{const s=t.content.at(e.index);switch(e.delta.type){case"text_delta":"text"===s?.type&&(t.content[e.index]={...s,text:(s.text||"")+e.delta.text});break;case"citations_delta":"text"===s?.type&&(t.content[e.index]={...s,citations:[...s.citations??[],e.delta.citation]});break;case"input_json_delta":if(s&&Xt(s)){let r=s[Vt]||"";r+=e.delta.partial_json;const n={...s};Object.defineProperty(n,Vt,{value:r,enumerable:!1,writable:!0}),r&&(n.input=Ie(r)),t.content[e.index]=n}break;case"thinking_delta":"thinking"===s?.type&&(t.content[e.index]={...s,thinking:s.thinking+e.delta.thinking});break;case"signature_delta":"thinking"===s?.type&&(t.content[e.index]={...s,signature:e.delta.signature});break;default:e.delta}return t}}},Symbol.asyncIterator)](){const e=[],t=[];let s=!1;return this.on("streamEvent",s=>{const r=t.shift();r?r.resolve(s):e.push(s)}),this.on("end",()=>{s=!0;for(const e of t)e.resolve(void 0);t.length=0}),this.on("abort",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),this.on("error",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),{next:async()=>e.length?{value:e.shift(),done:!1}:s?{value:void 0,done:!0}:new Promise((e,s)=>t.push({resolve:e,reject:s})).then(e=>e?{value:e,done:!1}:{value:void 0,done:!0}),return:async()=>(this.abort(),{value:void 0,done:!0})}}toReadableStream(){return new Z(this[Symbol.asyncIterator].bind(this),this.controller).toReadableStream()}}class Yt extends ye{create(e,t){return this._client.post("/v1/messages/batches",{body:e,...t})}retrieve(e,t){return this._client.get(Pe`/v1/messages/batches/${e}`,t)}list(e={},t){return this._client.getAPIList("/v1/messages/batches",oe,{query:e,...t})}delete(e,t){return this._client.delete(Pe`/v1/messages/batches/${e}`,t)}cancel(e,t){return this._client.post(Pe`/v1/messages/batches/${e}/cancel`,t)}async results(e,t){const s=await this.retrieve(e);if(!s.results_url)throw new o(`No batch \`results_url\`; Has it finished processing? ${s.processing_status} - ${s.id}`);return this._client.get(s.results_url,{...t,headers:_e([{Accept:"application/binary"},t?.headers]),stream:!0,__binaryResponse:!0})._thenUnwrap((e,t)=>yt.fromResponse(t.response,t.controller))}}class Qt extends ye{constructor(){super(...arguments),this.batches=new Yt(this._client)}create(e,t){e.model in Zt&&console.warn(`The model '${e.model}' is deprecated and will reach end-of-life on ${Zt[e.model]}\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`);let s=this._client._options.timeout;if(!e.stream&&null==s){const t=xe[e.model]??void 0;s=this._client.calculateNonstreamingTimeout(e.max_tokens,t)}return this._client.post("/v1/messages",{body:e,timeout:s??6e5,...t,stream:e.stream??!1})}stream(e,t){return Gt.createMessage(this,e,t)}countTokens(e,t){return this._client.post("/v1/messages/count_tokens",{body:e,...t})}}const Zt={"claude-1.3":"November 6th, 2024","claude-1.3-100k":"November 6th, 2024","claude-instant-1.1":"November 6th, 2024","claude-instant-1.1-100k":"November 6th, 2024","claude-instant-1.2":"November 6th, 2024","claude-3-sonnet-20240229":"July 21st, 2025","claude-3-opus-20240229":"January 5th, 2026","claude-2.1":"July 21st, 2025","claude-2.0":"July 21st, 2025","claude-3-7-sonnet-latest":"February 19th, 2026","claude-3-7-sonnet-20250219":"February 19th, 2026"};Qt.Batches=Yt;class es extends ye{retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/models/${e}`,{...s,headers:_e([{...null!=r?.toString()?{"anthropic-beta":r?.toString()}:void 0},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/models",oe,{query:r,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers])})}}const ts=e=>void 0!==globalThis.process?globalThis.process.env?.[e]?.trim()??void 0:void 0!==globalThis.Deno?globalThis.Deno.env?.get?.(e)?.trim():void 0;var ss,rs,ns,as,os,is;class cs{constructor({baseURL:e=ts("ANTHROPIC_BASE_URL"),apiKey:s=ts("ANTHROPIC_API_KEY")??null,authToken:r=ts("ANTHROPIC_AUTH_TOKEN")??null,...n}={}){ss.add(this),ns.set(this,void 0);const a={apiKey:s,authToken:r,...n,baseURL:e||"https://api.anthropic.com"};if(!a.dangerouslyAllowBrowser&&"undefined"!=typeof window&&void 0!==window.document&&"undefined"!=typeof navigator)throw new o("It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\nIf you understand the risks and have appropriate mitigations in place,\nyou can set the `dangerouslyAllowBrowser` option to `true`, e.g.,\n\nnew Anthropic({ apiKey, dangerouslyAllowBrowser: true });\n");this.baseURL=a.baseURL,this.timeout=a.timeout??rs.DEFAULT_TIMEOUT,this.logger=a.logger??console;const i="warn";this.logLevel=i,this.logLevel=B(a.logLevel,"ClientOptions.logLevel",this)??B(ts("ANTHROPIC_LOG"),"process.env['ANTHROPIC_LOG']",this)??i,this.fetchOptions=a.fetchOptions,this.maxRetries=a.maxRetries??2,this.fetch=a.fetch??function(){if("undefined"!=typeof fetch)return fetch;throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Anthropic({ fetch })` or polyfill the global, `globalThis.fetch = fetch`")}(),t(this,ns,I,"f"),this._options=a,this.apiKey="string"==typeof s?s:null,this.authToken=r}withOptions(e){return new this.constructor({...this._options,baseURL:this.baseURL,maxRetries:this.maxRetries,timeout:this.timeout,logger:this.logger,logLevel:this.logLevel,fetch:this.fetch,fetchOptions:this.fetchOptions,apiKey:this.apiKey,authToken:this.authToken,...e})}defaultQuery(){return this._options.defaultQuery}validateHeaders({values:e,nulls:t}){if(!e.get("x-api-key")&&!e.get("authorization")&&!(this.apiKey&&e.get("x-api-key")||t.has("x-api-key")||this.authToken&&e.get("authorization")||t.has("authorization")))throw new Error('Could not resolve authentication method. Expected either apiKey or authToken to be set. Or for one of the "X-Api-Key" or "Authorization" headers to be explicitly omitted')}async authHeaders(e){return _e([await this.apiKeyAuth(e),await this.bearerAuth(e)])}async apiKeyAuth(e){if(null!=this.apiKey)return _e([{"X-Api-Key":this.apiKey}])}async bearerAuth(e){if(null!=this.authToken)return _e([{Authorization:`Bearer ${this.authToken}`}])}stringifyQuery(e){return Object.entries(e).filter(([e,t])=>void 0!==t).map(([e,t])=>{if("string"==typeof t||"number"==typeof t||"boolean"==typeof t)return`${encodeURIComponent(e)}=${encodeURIComponent(t)}`;if(null===t)return`${encodeURIComponent(e)}=`;throw new o(`Cannot stringify type ${typeof t}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`)}).join("&")}getUserAgent(){return`${this.constructor.name}/JS ${M}`}defaultIdempotencyKey(){return`stainless-node-retry-${r()}`}makeStatusError(e,t,s,r){return i.generate(e,t,s,r)}buildURL(e,t,r){const n=!s(this,ss,"m",as).call(this)&&r||this.baseURL,a=(e=>b.test(e))(e)?new URL(e):new URL(n+(n.endsWith("/")&&e.startsWith("/")?e.slice(1):e)),o=this.defaultQuery();return function(e){if(!e)return!0;for(const t in e)return!1;return!0}(o)||(t={...o,...t}),"object"==typeof t&&t&&!Array.isArray(t)&&(a.search=this.stringifyQuery(t)),a.toString()}_calculateNonstreamingTimeout(e){if(3600*e/128e3>600)throw new o("Streaming is required for operations that may take longer than 10 minutes. See https://github.com/anthropics/anthropic-sdk-typescript#streaming-responses for more details");return 6e5}async prepareOptions(e){}async prepareRequest(e,{url:t,options:s}){}get(e,t){return this.methodRequest("get",e,t)}post(e,t){return this.methodRequest("post",e,t)}patch(e,t){return this.methodRequest("patch",e,t)}put(e,t){return this.methodRequest("put",e,t)}delete(e,t){return this.methodRequest("delete",e,t)}methodRequest(e,t,s){return this.request(Promise.resolve(s).then(s=>({method:e,path:t,...s})))}request(e,t=null){return new re(this,this.makeRequest(e,t,void 0))}async makeRequest(e,t,s){const r=await e,o=r.maxRetries??this.maxRetries;null==t&&(t=o),await this.prepareOptions(r);const{req:i,url:h,timeout:u}=await this.buildRequest(r,{retryCount:o-t});await this.prepareRequest(i,{url:h,options:r});const p="log_"+(Math.random()*(1<<24)|0).toString(16).padStart(6,"0"),f=void 0===s?"":`, retryOf: ${s}`,m=Date.now();if(V(this).debug(`[${p}] sending request`,X({retryOfRequestLogID:s,method:r.method,url:h,options:r,headers:i.headers})),r.signal?.aborted)throw new c;const g=new AbortController,w=await this.fetchWithTimeout(h,i,u,g).catch(a),y=Date.now();if(w instanceof globalThis.Error){const e=`retrying, ${t} attempts remaining`;if(r.signal?.aborted)throw new c;const a=n(w)||/timed? ?out/i.test(String(w)+("cause"in w?String(w.cause):""));if(t)return V(this).info(`[${p}] connection ${a?"timed out":"failed"} - ${e}`),V(this).debug(`[${p}] connection ${a?"timed out":"failed"} (${e})`,X({retryOfRequestLogID:s,url:h,durationMs:y-m,message:w.message})),this.retryRequest(r,t,s??p);if(V(this).info(`[${p}] connection ${a?"timed out":"failed"} - error; no more retries left`),V(this).debug(`[${p}] connection ${a?"timed out":"failed"} (error; no more retries left)`,X({retryOfRequestLogID:s,url:h,durationMs:y-m,message:w.message})),a)throw new d;throw new l({cause:w})}const b=`[${p}${f}${[...w.headers.entries()].filter(([e])=>"request-id"===e).map(([e,t])=>", "+e+": "+JSON.stringify(t)).join("")}] ${i.method} ${h} ${w.ok?"succeeded":"failed"} with status ${w.status} in ${y-m}ms`;if(!w.ok){const e=await this.shouldRetry(w);if(t&&e){const e=`retrying, ${t} attempts remaining`;return await async function(e){if(null===e||"object"!=typeof e)return;if(e[Symbol.asyncIterator])return void await(e[Symbol.asyncIterator]().return?.());const t=e.getReader(),s=t.cancel();t.releaseLock(),await s}(w.body),V(this).info(`${b} - ${e}`),V(this).debug(`[${p}] response error (${e})`,X({retryOfRequestLogID:s,url:w.url,status:w.status,headers:w.headers,durationMs:y-m})),this.retryRequest(r,t,s??p,w.headers)}const n=e?"error; no more retries left":"error; not retryable";V(this).info(`${b} - ${n}`);const o=await w.text().catch(e=>a(e).message),i=S(o),c=i?void 0:o;throw V(this).debug(`[${p}] response error (${n})`,X({retryOfRequestLogID:s,url:w.url,status:w.status,headers:w.headers,message:c,durationMs:Date.now()-m})),this.makeStatusError(w.status,i,c,w.headers)}return V(this).info(b),V(this).debug(`[${p}] response start`,X({retryOfRequestLogID:s,url:w.url,status:w.status,headers:w.headers,durationMs:y-m})),{response:w,options:r,controller:g,requestLogID:p,retryOfRequestLogID:s,startTime:m}}getAPIList(e,t,s){return this.requestAPIList(t,{method:"get",path:e,...s})}requestAPIList(e,t){const s=this.makeRequest(t,null,void 0);return new ae(this,s,e)}async fetchWithTimeout(e,t,s,r){const{signal:n,method:a,...o}=t||{};n&&n.addEventListener("abort",()=>r.abort());const i=setTimeout(()=>r.abort(),s),c=globalThis.ReadableStream&&o.body instanceof globalThis.ReadableStream||"object"==typeof o.body&&null!==o.body&&Symbol.asyncIterator in o.body,l={signal:r.signal,...c?{duplex:"half"}:{},method:"GET",...o};a&&(l.method=a.toUpperCase());try{return await this.fetch.call(void 0,e,l)}finally{clearTimeout(i)}}async shouldRetry(e){const t=e.headers.get("x-should-retry");return"true"===t||"false"!==t&&(408===e.status||409===e.status||429===e.status||e.status>=500)}async retryRequest(e,t,s,r){let n;const a=r?.get("retry-after-ms");if(a){const e=parseFloat(a);Number.isNaN(e)||(n=e)}const o=r?.get("retry-after");if(o&&!n){const e=parseFloat(o);n=Number.isNaN(e)?Date.parse(o)-Date.now():1e3*e}if(!(n&&0<=n&&n<6e4)){const s=e.maxRetries??this.maxRetries;n=this.calculateDefaultRetryTimeoutMillis(t,s)}var i;return await(i=n,new Promise(e=>setTimeout(e,i))),this.makeRequest(e,t-1,s)}calculateDefaultRetryTimeoutMillis(e,t){const s=t-e;return Math.min(.5*Math.pow(2,s),8)*(1-.25*Math.random())*1e3}calculateNonstreamingTimeout(e,t){const s=6e5;if(36e5*e/128e3>s||null!=t&&e>t)throw new o("Streaming is required for operations that may take longer than 10 minutes. See https://github.com/anthropics/anthropic-sdk-typescript#long-requests for more details");return s}async buildRequest(e,{retryCount:t=0}={}){const s={...e},{method:r,path:n,query:a,defaultBaseURL:i}=s,c=this.buildURL(n,a,i);"timeout"in s&&((e,t)=>{if("number"!=typeof t||!Number.isInteger(t))throw new o(`${e} must be an integer`);if(t<0)throw new o(`${e} must be a positive integer`)})("timeout",s.timeout),s.timeout=s.timeout??this.timeout;const{bodyHeaders:l,body:d}=this.buildBody({options:s});return{req:{method:r,headers:await this.buildHeaders({options:e,method:r,bodyHeaders:l,retryCount:t}),...s.signal&&{signal:s.signal},...globalThis.ReadableStream&&d instanceof globalThis.ReadableStream&&{duplex:"half"},...d&&{body:d},...this.fetchOptions??{},...s.fetchOptions??{}},url:c,timeout:s.timeout}}async buildHeaders({options:e,method:t,bodyHeaders:s,retryCount:r}){let n={};this.idempotencyHeader&&"get"!==t&&(e.idempotencyKey||(e.idempotencyKey=this.defaultIdempotencyKey()),n[this.idempotencyHeader]=e.idempotencyKey);const a=_e([n,{Accept:"application/json","User-Agent":this.getUserAgent(),"X-Stainless-Retry-Count":String(r),...e.timeout?{"X-Stainless-Timeout":String(Math.trunc(e.timeout/1e3))}:{},...x??(x=P()),...this._options.dangerouslyAllowBrowser?{"anthropic-dangerous-direct-browser-access":"true"}:void 0,"anthropic-version":"2023-06-01"},await this.authHeaders(e),this._options.defaultHeaders,s,e.headers]);return this.validateHeaders(a),a.values}buildBody({options:{body:e,headers:t}}){if(!e)return{bodyHeaders:void 0,body:void 0};const r=_e([t]);return ArrayBuffer.isView(e)||e instanceof ArrayBuffer||e instanceof DataView||"string"==typeof e&&r.values.has("content-type")||globalThis.Blob&&e instanceof globalThis.Blob||e instanceof FormData||e instanceof URLSearchParams||globalThis.ReadableStream&&e instanceof globalThis.ReadableStream?{bodyHeaders:void 0,body:e}:"object"==typeof e&&(Symbol.asyncIterator in e||Symbol.iterator in e&&"next"in e&&"function"==typeof e.next)?{bodyHeaders:void 0,body:A(e)}:s(this,ns,"f").call(this,{body:e,headers:r})}}rs=cs,ns=new WeakMap,ss=new WeakSet,as=function(){return"https://api.anthropic.com"!==this.baseURL},cs.Anthropic=rs,cs.HUMAN_PROMPT="\\n\\nHuman:",cs.AI_PROMPT="\\n\\nAssistant:",cs.DEFAULT_TIMEOUT=6e5,cs.AnthropicError=o,cs.APIError=i,cs.APIConnectionError=l,cs.APIConnectionTimeoutError=d,cs.APIUserAbortError=c,cs.NotFoundError=f,cs.ConflictError=m,cs.RateLimitError=w,cs.BadRequestError=h,cs.AuthenticationError=u,cs.InternalServerError=y,cs.PermissionDeniedError=p,cs.UnprocessableEntityError=g,cs.toFile=async function(e,t,s){if(ce(),e=await e,t||(t=de(e)),(e=>null!=e&&"object"==typeof e&&"string"==typeof e.name&&"number"==typeof e.lastModified&&ge(e))(e))return e instanceof File&&null==t&&null==s?e:le([await e.arrayBuffer()],t??e.name,{type:e.type,lastModified:e.lastModified,...s});if((e=>null!=e&&"object"==typeof e&&"string"==typeof e.url&&"function"==typeof e.blob)(e)){const r=await e.blob();return t||(t=new URL(e.url).pathname.split(/[\\/]/).pop()),le(await we(r),t,s)}const r=await we(e);if(!s?.type){const e=r.find(e=>"object"==typeof e&&"type"in e&&e.type);"string"==typeof e&&(s={...s,type:e})}return le(r,t,s)};class ls extends cs{constructor(){super(...arguments),this.completions=new Pt(this),this.messages=new Qt(this),this.models=new es(this),this.beta=new Mt(this)}}ls.Completions=Pt,ls.Messages=Qt,ls.Models=es,ls.Beta=Mt;class ds{validateModel(e){if(null===this.availableModels||0===this.availableModels.length)return!0;if(!this.availableModels.includes(e))throw new Error(`Model '${e}' is not available for provider '${this.name}'. Available models: ${this.availableModels.join(", ")}`);return!0}validateRequest(e){if(!e.model||0===e.model.trim().length)throw new Error("Model is required");if(!e.messages||0===e.messages.length)throw new Error("Messages array is required and must not be empty");if(void 0!==e.max_tokens&&e.max_tokens<=0)throw new Error("max_tokens must be positive");if(void 0!==e.temperature&&(e.temperature<0||e.temperature>2))throw new Error("temperature must be between 0 and 2");this.validateModel(e.model)}validateCredentialsStructure(e){if(!e||!e.apiKey)throw new Error("API key is required");if("string"!=typeof e.apiKey||0===e.apiKey.trim().length)throw new Error("API key must be a non-empty string")}}class hs extends ds{constructor(){super(...arguments),this.name="anthropic",this._availableModels=null,this.defaultModels=null}get availableModels(){return this._availableModels}async fetchAvailableModels(e){this.validateCredentialsStructure(e);try{const t=new ls({apiKey:e.apiKey,dangerouslyAllowBrowser:!0}),s=(await t.models.list()).data;return this._availableModels=s.map(e=>e.id),s}catch(e){throw console.error("Failed to fetch models from Anthropic API:",e),new Error(`Failed to fetch available models: ${e?.message||"Unknown error"}`)}}getLatestModelByFamily(e,t){const s=e.filter(e=>e.id.toLowerCase().includes(t.toLowerCase()));if(0!==s.length)return s.sort((e,t)=>{const s=new Date(e.created_at).getTime();return new Date(t.created_at).getTime()-s}),s[0].id}async validateCredentials(e){this.validateCredentialsStructure(e);try{return await this.fetchAvailableModels(e),!0}catch(e){if(401===e?.status||e?.message?.includes("authentication"))throw new Error("Invalid API key");throw new Error(`Credential validation failed: ${e?.message||"Unknown error"}`)}}async makeRequest(e,t,s){this.validateRequest(e),this.validateCredentialsStructure(t);const r=new ls({apiKey:t.apiKey,dangerouslyAllowBrowser:!0});try{return e.stream&&s?await this.handleStreamingRequest(r,e,s):await this.handleNonStreamingRequest(r,e)}catch(e){throw this.handleError(e)}}async handleNonStreamingRequest(e,t){const s=await e.messages.create({model:t.model,max_tokens:t.max_tokens??4096,temperature:t.temperature,system:t.system,messages:t.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content}))}),r=s.content.find(e=>"text"===e.type);return{content:r&&"text"in r?r.text:"",model:s.model,provider:"anthropic",usage:{input_tokens:s.usage.input_tokens,output_tokens:s.usage.output_tokens},stop_reason:s.stop_reason??void 0}}async handleStreamingRequest(e,t,s){const r=await e.messages.create({model:t.model,max_tokens:t.max_tokens??4096,temperature:t.temperature,system:t.system,messages:t.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content})),stream:!0});let n,a="",o=t.model,i=0,c=0;for await(const e of r)if("message_start"===e.type)o=e.message.model,i=e.message.usage.input_tokens;else if("content_block_delta"===e.type){if("text_delta"===e.delta.type){const t=e.delta.text;a+=t,s(t)}}else"message_delta"===e.type&&(c=e.usage.output_tokens,n=e.delta.stop_reason??void 0);return{content:a,model:o,provider:"anthropic",usage:{input_tokens:i,output_tokens:c},stop_reason:n}}handleError(e){return 401===e?.status?new Error("Invalid API key or authentication failed"):429===e?.status?new Error("Rate limit exceeded. Please try again later."):400===e?.status?new Error(`Bad request: ${e?.message||"Invalid parameters"}`):500===e?.status?new Error("Anthropic API error. Please try again."):new Error(`API request failed: ${e?.message||"Unknown error"}`)}}class us extends ds{constructor(e){super(),this.name="anthropic",this._availableModels=null,this.defaultModels=null,this.serverUrl=e.credentialServerUrl.replace(/\/$/,"")}get availableModels(){return this._availableModels}async checkAuthStatus(){return(await fetch(`${this.serverUrl}/status`,{method:"GET",credentials:"include"})).json()}getSetupUrl(){return`${this.serverUrl}/setup`}async fetchAvailableModels(e){try{const e=await fetch(`${this.serverUrl}/proxy?path=/v1/models`,{method:"GET",credentials:"include"});if(!e.ok)throw new Error(`Failed to fetch models: HTTP ${e.status}`);const t=((await e.json()).data||[]).map(e=>({id:e.id,display_name:e.display_name||e.id,created_at:e.created_at||(new Date).toISOString(),type:e.type||"model"}));return this._availableModels=t.map(e=>e.id),t}catch(e){throw console.error("[ProxiedAnthropicProvider] Failed to fetch models from API:",e.message),new Error(`Failed to fetch available models: ${e.message}`)}}getLatestModelByFamily(e,t){const s=e.filter(e=>e.id.toLowerCase().includes(t.toLowerCase()));if(0!==s.length)return s.sort((e,t)=>{const s=new Date(e.created_at).getTime();return new Date(t.created_at).getTime()-s}),s[0].id}async validateCredentials(e){return(await this.checkAuthStatus()).authenticated}async makeRequest(e,t,s){if(this.validateRequest(e),!(await this.checkAuthStatus()).authenticated)throw new Error(`Not authenticated. Please visit ${this.getSetupUrl()} to set up your API key.`);try{return e.stream&&s?await this.handleStreamingRequest(e,s):await this.handleNonStreamingRequest(e)}catch(e){throw this.handleError(e)}}async handleNonStreamingRequest(e){const t={model:e.model,max_tokens:e.max_tokens??4096,temperature:e.temperature,system:e.system,messages:e.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content}))},s=await fetch(`${this.serverUrl}/proxy?path=/v1/messages`,{method:"POST",headers:{"Content-Type":"application/json"},credentials:"include",body:JSON.stringify(t)});if(!s.ok){const e=await s.json().catch(()=>({error:"Unknown error"}));throw new Error(e.error?.message||e.error||`HTTP ${s.status}`)}const r=await s.json(),n=r.content?.find(e=>"text"===e.type);return{content:n&&"text"in n?n.text:"",model:r.model,provider:"anthropic",usage:{input_tokens:r.usage?.input_tokens||0,output_tokens:r.usage?.output_tokens||0},stop_reason:r.stop_reason??void 0}}async handleStreamingRequest(e,t){const s={model:e.model,max_tokens:e.max_tokens??4096,temperature:e.temperature,system:e.system,messages:e.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content})),stream:!0},r=await fetch(`${this.serverUrl}/proxy?path=/v1/messages`,{method:"POST",headers:{"Content-Type":"application/json"},credentials:"include",body:JSON.stringify(s)});if(!r.ok){const e=await r.json().catch(()=>({error:"Unknown error"}));throw new Error(e.error?.message||e.error||`HTTP ${r.status}`)}const n=r.body?.getReader();if(!n)throw new Error("Streaming not supported");const a=new TextDecoder;let o,i="",c=e.model,l=0,d=0;try{for(;;){const{done:e,value:s}=await n.read();if(e)break;const r=a.decode(s,{stream:!0}).split("\n");for(const e of r)if(e.startsWith("data: ")){const s=e.slice(6);if("[DONE]"===s)continue;try{const e=JSON.parse(s);if("message_start"===e.type)c=e.message.model,l=e.message.usage?.input_tokens||0;else if("content_block_delta"===e.type){if("text_delta"===e.delta?.type){const s=e.delta.text;i+=s,t(s)}}else"message_delta"===e.type&&(d=e.usage?.output_tokens||0,o=e.delta?.stop_reason??void 0)}catch{}}}}finally{n.releaseLock()}return{content:i,model:c,provider:"anthropic",usage:{input_tokens:l,output_tokens:d},stop_reason:o}}handleError(e){const t=e?.message||"Unknown error";return t.includes("401")||t.includes("authentication")?new Error(`Not authenticated. Please visit ${this.getSetupUrl()} to set up your API key.`):t.includes("429")?new Error("Rate limit exceeded. Please try again later."):t.includes("400")?new Error(`Bad request: ${t}`):new Error(`API request failed: ${t}`)}}class ps{constructor(e,t,s){this.isInitialized=!1,this.forceLocalMode=!1,this.configManager=e,this.credentialServerUrl=t,this.allowLocalMode=s??!1}setPromptHandler(e){this.promptHandler=e}static getInstance(e,t,s){if(!ps.instance){if(!e)throw new Error("ConfigManager required for first initialization");ps.instance=new ps(e,t,s)}return ps.instance}isProxiedMode(){return!!this.credentialServerUrl&&!this.forceLocalMode}isLocalModeAllowed(){return this.allowLocalMode}isLocalModeForced(){return this.forceLocalMode}async setForceLocalMode(e){if(this.forceLocalMode!==e){if(this.forceLocalMode=e,await this.configManager.setForceLocalMode(e),this.credentials=void 0,this.weightMapper){const e=this.weightMapper.getProvider();this.provider=this.createProvider(e)}console.log("[AiDelegateCore] Switched mode",{forceLocalMode:e,isProxiedMode:this.isProxiedMode()})}}async configureLocal(t,s,r=!0){this.isInitialized||await this.initialize(),this.forceLocalMode=!0,await this.configManager.saveLocal(t,s,r),this.provider=this.createProvider(t.provider),this.weightMapper=new e(t.provider,t.models),t.credentials&&(this.credentials=t.credentials),console.log("[AiDelegateCore] Configured local mode",{provider:t.provider,hasPassword:!!s})}getCredentialServerSetupUrl(){return this.credentialServerUrl?`${this.credentialServerUrl}/setup`:null}async fetchAvailableModels(){if(await this.ensureInitialized(),!this.provider)throw new Error("Provider not configured");const e=this.credentials||{apiKey:"proxied"};console.log("[AiDelegateCore] Fetching available models from provider");const t=await this.provider.fetchAvailableModels(e);return console.log("[AiDelegateCore] Fetched models:",t.map(e=>e.id)),t}async ensureInitialized(){this.isInitialized||await this.initialize()}async initialize(){if(this.isInitialized)return void console.log("[AiDelegateCore] Already initialized, skipping");this.forceLocalMode=await this.configManager.getForceLocalMode(),console.log("[AiDelegateCore] Initializing...",{isProxiedMode:this.isProxiedMode(),credentialServerUrl:this.credentialServerUrl,forceLocalMode:this.forceLocalMode,allowLocalMode:this.allowLocalMode});const t=await this.configManager.loadMetadata();if(console.log("[AiDelegateCore] Loaded metadata:",t),t){console.log("[AiDelegateCore] Using existing metadata"),this.provider=this.createProvider(t.provider),this.weightMapper=new e(t.provider,t.models);const s=await this.configManager.getPlaintextCredentials();s?(console.log("[AiDelegateCore] Using plaintext credentials (local dev mode)"),this.credentials=s):this.isProxiedMode()&&(this.credentials={apiKey:"proxied"})}else this.isProxiedMode()?(console.log("[AiDelegateCore] No metadata, initializing proxied defaults"),await this.initializeProxiedDefaults()):console.log("[AiDelegateCore] No metadata and not proxied mode - uninitialized");console.log("[AiDelegateCore] Initialization complete",{provider:!!this.provider,weightMapper:!!this.weightMapper,credentials:!!this.credentials}),this.isInitialized=!0}async initializeProxiedDefaults(){this.provider=this.createProvider("anthropic"),this.weightMapper=new e("anthropic",{}),this.credentials={apiKey:"proxied"},await this.configManager.saveMetadata("anthropic",{},!0)}async configure(e,t,s=!1){await this.applyConfig(e),await this.configManager.save(e,t,s)}async applyConfig(t){if(this.provider=this.createProvider(t.provider),this.weightMapper=new e(t.provider,t.models),t.credentials){this.credentials=t.credentials;try{await this.provider.validateCredentials(t.credentials)}catch(e){throw new Error(`Credential validation failed: ${e.message}`)}}}async makeRequest(e){this.isInitialized||await this.initialize();const t=await this.getState();if("uninitialized"===t?await this.promptForConfigurationIfNeeded():"locked"===t&&await this.promptForUnlock(),!this.provider||!this.weightMapper)throw new Error("AiDelegate is not configured. Please call configure() with provider and credentials.");if(!this.credentials)throw new Error("No credentials available. Please provide password to unlock.");let s=this.weightMapper.getModel(e.weight);console.log(`[AiDelegateCore] makeRequest weight=${e.weight}, mapped model=${s}`),s||(console.log(`[AiDelegateCore] No model for weight ${e.weight}, auto-selecting...`),s=await this.ensureModelForWeight(e.weight),console.log(`[AiDelegateCore] Auto-selected model: ${s}`));const r={model:s,messages:e.messages,max_tokens:e.max_tokens,temperature:e.temperature,stream:e.stream,system:e.system};if(e.stream&&!e.onStream)throw new Error("onStream callback is required when stream=true");try{return await this.provider.makeRequest(r,this.credentials,e.onStream)}catch(e){throw new Error(`AI request failed: ${e.message}`)}}async ensureModelForWeight(e){if(!this.provider||!this.credentials)throw new Error("Provider and credentials must be configured first");const t=await this.provider.fetchAvailableModels(this.credentials);if(0===t.length)throw new Error("No models available from provider");let s;if(await this.configManager.getUseDefaultModels())s=await this.autoSelectModelForWeight(e,t);else{if(!this.promptHandler)throw new Error("Model selection required but prompt handler not set");s=await this.promptHandler.promptForModelSelection(e,t)}return await this.configManager.setModelForWeight(e,s),this.weightMapper&&this.weightMapper.setModel(e,s),s}async autoSelectModelForWeight(e,t){if(!this.provider)throw new Error("Provider not configured");const s={light:"haiku",moderate:"sonnet",heavy:"opus"}[e];if(this.provider instanceof hs){const e=this.provider.getLatestModelByFamily(t,s);if(e)return e}const r=t.filter(e=>e.id.toLowerCase().includes(s.toLowerCase())||e.display_name.toLowerCase().includes(s.toLowerCase()));if(0===r.length)throw new Error(`No ${s} models found for ${e} weight`);return r.sort((e,t)=>{const s=new Date(e.created_at).getTime();return new Date(t.created_at).getTime()-s}),r[0].id}async getStatus(){this.isInitialized||await this.initialize();const e=await this.getState();let t=await this.configManager.hasCredentials();if(this.isProxiedMode()){const e=this.provider;if(e&&"function"==typeof e.checkAuthStatus)try{t=(await e.checkAuthStatus()).authenticated}catch{}}return{state:e,configured:!!this.provider&&!!this.weightMapper,hasCredentials:t,provider:this.provider?.name,models:this.weightMapper?.getMapping(),cacheEnabled:!1,trackingEnabled:!1}}async lock(){this.credentials=void 0,await this.configManager.clearCredentials()}async reset(){this.provider=void 0,this.weightMapper=void 0,this.credentials=void 0,this.isInitialized=!1,await this.configManager.clear()}createProvider(e){switch(e){case"anthropic":return this.isProxiedMode()?new us({credentialServerUrl:this.credentialServerUrl}):new hs;case"openai":throw new Error("OpenAI provider not yet implemented");default:throw new Error(`Unknown provider: ${e}`)}}async updateCredentials(e,t){if(!this.provider)throw new Error("Provider not configured. Call configure() first.");await this.provider.validateCredentials(e),this.credentials=e,await this.configManager.updateCredentials(e,t)}async isReady(){if(this.isInitialized||await this.initialize(),this.isProxiedMode()){const e=this.provider;if(e&&"function"==typeof e.checkAuthStatus)try{const t=await e.checkAuthStatus();return!!this.provider&&!!this.weightMapper&&t.authenticated}catch{return!1}}return!!this.provider&&!!this.weightMapper&&!!this.credentials}async getState(){if(this.isProxiedMode()){const e=this.provider;if(e&&"function"==typeof e.checkAuthStatus)try{if((await e.checkAuthStatus()).authenticated)return"unlocked"}catch{}return"uninitialized"}return await this.configManager.hasConfig()?this.credentials?"unlocked":"locked":"uninitialized"}async promptForConfigurationIfNeeded(){if(!this.promptHandler)throw new Error("Configuration required. Prompt handler not set. This should only be called from worker context with a prompt handler.");try{const e=await this.promptHandler.promptForConfiguration();await this.configure(e.config,e.password,e.useDefaultModels)}catch(e){throw new Error(`Configuration required: ${e.message}`)}}async promptForUnlock(){if(!this.promptHandler)throw new Error("Password required to unlock. Prompt handler not set. This should only be called from worker context with a prompt handler.");try{const e=await this.promptHandler.promptForUnlock();await this.unlock(e)}catch(e){throw new Error(`Unlock required: ${e.message}`)}}async unlock(e){const t=await this.configManager.unlock(e);await this.applyConfig(t)}}!function(e){e.INIT="init",e.CONFIGURE="configure",e.MAKE_REQUEST="makeRequest",e.GET_STATUS="getStatus",e.LOCK="lock",e.RESET="reset",e.UPDATE_CREDENTIALS="updateCredentials",e.IS_READY="isReady",e.UNLOCK="unlock",e.GET_SETUP_URL="getSetupUrl",e.SET_LOCAL_MODE="setLocalMode",e.IS_LOCAL_MODE_ALLOWED="isLocalModeAllowed",e.IS_LOCAL_MODE_FORCED="isLocalModeForced",e.CONFIGURE_LOCAL="configureLocal",e.FETCH_MODELS="fetchModels",e.REGISTER_PROMPT="registerPrompt",e.REGISTER_PROMPTS="registerPrompts",e.GET_PROMPT="getPrompt",e.LIST_PROMPTS="listPrompts",e.UPDATE_PROMPT="updatePrompt",e.DELETE_PROMPT="deletePrompt",e.RESET_PROMPT="resetPrompt",e.RESOLVE_CONFLICT="resolveConflict",e.RENDER_PROMPT="renderPrompt"}(os||(os={})),function(e){e.CONFIGURE="configure",e.UNLOCK="unlock",e.MODEL_SELECT="modelSelect",e.PROMPT_CONFLICT="promptConflict"}(is||(is={}));class fs{static validateMessage(e){return!(!e||"object"!=typeof e||"string"!=typeof e.id||0===e.id.length||!Object.values(os).includes(e.command))}static createSuccessResponse(e,t){return{id:e,success:!0,data:t}}static createErrorResponse(e,t){const s="string"==typeof t?t:t.message;return{id:e,success:!1,error:{message:this.sanitizeErrorMessage(s)}}}static sanitizeErrorMessage(e){return e.replace(/sk-ant-[a-zA-Z0-9_-]+/g,"[API_KEY_REDACTED]").replace(/sk-[a-zA-Z0-9_-]{48,}/g,"[API_KEY_REDACTED]").replace(/(api[_-]?key|token|password|secret)[:\s=]+[^\s]+/gi,"$1: [REDACTED]")}static generateId(){return`${Date.now()}-${Math.random().toString(36).substring(2,11)}`}}const ms="AES-GCM";async function gs(e,t){const s=new TextEncoder,r=await crypto.subtle.importKey("raw",s.encode(e),"PBKDF2",!1,["deriveKey"]);return crypto.subtle.deriveKey({name:"PBKDF2",salt:t,iterations:1e5,hash:"SHA-256"},r,{name:ms,length:256},!1,["encrypt","decrypt"])}const ws="0.1.0",ys="ai-delegate-config",bs=3e5,vs="prompts";class _s{constructor(){this.db=null}async initDB(){return this.db?this.db:new Promise((e,t)=>{const s=indexedDB.open("ai-delegate-prompts",1);s.onerror=()=>{t(new Error(`Failed to open IndexedDB: ${s.error}`))},s.onsuccess=()=>{this.db=s.result,e(this.db)},s.onupgradeneeded=e=>{const t=e.target.result;if(!t.objectStoreNames.contains(vs)){const e=t.createObjectStore(vs,{keyPath:"name"});e.createIndex("version","version",{unique:!1}),e.createIndex("locallyModified","locallyModified",{unique:!1})}}})}async get(e){try{const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([vs],"readonly").objectStore(vs).get(e);n.onsuccess=()=>{s(n.result??null)},n.onerror=()=>{r(new Error(`Failed to get prompt: ${n.error}`))}})}catch(e){return console.error("[PromptStore] get error:",e),null}}async put(e){const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([vs],"readwrite").objectStore(vs).put(e);n.onsuccess=()=>{s()},n.onerror=()=>{r(new Error(`Failed to save prompt: ${n.error}`))}})}async delete(e){const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([vs],"readwrite").objectStore(vs).delete(e);n.onsuccess=()=>{s()},n.onerror=()=>{r(new Error(`Failed to delete prompt: ${n.error}`))}})}async list(){const e=await this.initDB();return new Promise((t,s)=>{const r=e.transaction([vs],"readonly").objectStore(vs).getAll();r.onsuccess=()=>{t(r.result??[])},r.onerror=()=>{s(new Error(`Failed to list prompts: ${r.error}`))}})}async exists(e){return null!==await this.get(e)}async getModified(){const e=await this.initDB();return new Promise((t,s)=>{const r=e.transaction([vs],"readonly").objectStore(vs).index("locallyModified").getAll(IDBKeyRange.only(!0));r.onsuccess=()=>{t(r.result??[])},r.onerror=()=>{s(new Error(`Failed to get modified prompts: ${r.error}`))}})}static createStoredPrompt(e,t,s){const r=(new Date).toISOString();return{...s,name:e,version:t,locallyModified:!1,createdAt:r,updatedAt:r}}async clear(){const e=await this.initDB();return new Promise((t,s)=>{const r=e.transaction([vs],"readwrite").objectStore(vs).clear();r.onsuccess=()=>{t()},r.onerror=()=>{s(new Error(`Failed to clear prompts: ${r.error}`))}})}}class ks extends Error{constructor(e,t){super(`Undefined parameter: ${e}${t?` in prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="UndefinedParamError"}}class Ss extends Error{constructor(e,t){super(`Unreferenced parameter: ${e}${t?` in prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="UnreferencedParamError"}}class Ms extends Error{constructor(e,t){super(`Missing required parameter: ${e}${t?` for prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="MissingParamError"}}class Ps extends Error{constructor(e,t){super(`Unknown parameter: ${e}${t?` for prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="UnknownParamError"}}const Es=/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;class Rs{extractParams(e){const t=[];let s;for(Es.lastIndex=0;null!==(s=Es.exec(e));){const e=s[1];t.includes(e)||t.push(e)}return t}validateDefinition(e,t){const s=this.extractParams(e.template),r=Object.keys(e.params??{});for(const e of s)if(!r.includes(e))throw new ks(e,t);for(const e of r)if(!s.includes(e))throw new Ss(e,t);if(e.role&&!["user","assistant","system"].includes(e.role))throw new Error(`Invalid role "${e.role}" for prompt${t?` "${t}"`:""}`)}render(e,t,s){const r=this.extractParams(e),n={};for(const e of r)if(e in s)n[e]=s[e];else{if(!(e in t)||void 0===t[e].default)throw new Ms(e);n[e]=t[e].default}for(const e of Object.keys(s))if(!r.includes(e))throw new Ps(e);return e.replace(Es,(e,t)=>n[t])}renderWithSingleParam(e,t,s){let r={};if(void 0===s)r={};else if("string"==typeof s){const n=this.extractParams(e),a=n.filter(e=>!(e in t)||void 0===t[e].default),o=n.filter(e=>e in t&&void 0!==t[e].default);if(1===a.length)r[a[0]]=s;else{if(a.length>1)throw new Error(`Ambiguous single parameter: multiple required params (${a.join(", ")})`);if(1!==o.length)throw o.length>1?new Error(`Ambiguous single parameter: multiple optional params (${o.join(", ")})`):new Error("Prompt takes no parameters");r[o[0]]=s}}else r=s;return this.render(e,t,r)}}console.log("[AI Delegate Worker] Version: 0.3.4");const xs=new class{constructor(){this.dbName="ai-delegate-storage",this.storeName="config",this.db=null}async initDB(){return this.db?this.db:new Promise((e,t)=>{const s=indexedDB.open(this.dbName,1);s.onerror=()=>{t(new Error(`Failed to open IndexedDB: ${s.error}`))},s.onsuccess=()=>{this.db=s.result,e(this.db)},s.onupgradeneeded=e=>{const t=e.target.result;t.objectStoreNames.contains(this.storeName)||t.createObjectStore(this.storeName)}})}async getItem(e){try{const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([this.storeName],"readonly").objectStore(this.storeName).get(e);n.onsuccess=()=>{s(n.result??null)},n.onerror=()=>{r(new Error(`Failed to get item: ${n.error}`))}})}catch(e){return console.error("[IndexedDBAdapter] getItem error:",e),null}}async setItem(e,t){const s=await this.initDB();return new Promise((r,n)=>{const a=s.transaction([this.storeName],"readwrite").objectStore(this.storeName).put(t,e);a.onsuccess=()=>{r()},a.onerror=()=>{n(new Error(`Failed to set item: ${a.error}`))}})}async removeItem(e){const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([this.storeName],"readwrite").objectStore(this.storeName).delete(e);n.onsuccess=()=>{s()},n.onerror=()=>{r(new Error(`Failed to remove item: ${n.error}`))}})}async hasItem(e){try{return null!==await this.getItem(e)}catch(e){return!1}}},Ts=new class{constructor(e){if("undefined"==typeof crypto||void 0===crypto.subtle||"function"!=typeof crypto.getRandomValues)throw new Error("Web Crypto API not available. This library requires a modern browser with crypto support.");this.storage=e}async save(e,t,s=!1){if(!t||0===t.trim().length)throw new Error("Password is required to save configuration");const r={provider:e.provider,models:e.models,useDefaultModels:s,enableCache:e.enableCache??!1,cacheTTL:e.cacheTTL??bs,trackUsage:e.trackUsage??!1,version:ws};e.credentials&&(r.encryptedCredentials=await this.encryptCredentials(e.credentials,t));try{await this.storage.setItem(ys,JSON.stringify(r))}catch(e){throw new Error(`Failed to save configuration: ${e?.message||"Unknown error"}`)}}async loadMetadata(){try{const e=await this.storage.getItem(ys);if(!e)return null;const t=JSON.parse(e);return t.version!==ws&&console.warn(`Configuration version mismatch. Expected ${ws}, got ${t.version}`),{provider:t.provider,models:t.models,enableCache:t.enableCache,cacheTTL:t.cacheTTL,trackUsage:t.trackUsage}}catch(e){return console.error("Failed to load configuration:",e),null}}async unlock(e){if(!e||0===e.trim().length)throw new Error("Password is required to unlock credentials");const t=await this.storage.getItem(ys);if(!t)throw new Error("No configuration found");const s=JSON.parse(t);if(!s.encryptedCredentials)throw new Error("No encrypted credentials found");const r=await this.decryptCredentials(s.encryptedCredentials,e);return{provider:s.provider,models:s.models,enableCache:s.enableCache,cacheTTL:s.cacheTTL,trackUsage:s.trackUsage,credentials:r}}async clear(){await this.storage.removeItem(ys)}async hasConfig(){return await this.storage.hasItem(ys)}async updateCredentials(e,t){const s=await this.loadMetadata();if(!s)throw new Error("No configuration found. Please configure the provider first.");const r={...s,credentials:e};await this.save(r,t)}async clearCredentials(){const e=await this.storage.getItem(ys);if(!e)return;const t=JSON.parse(e);delete t.encryptedCredentials,await this.storage.setItem(ys,JSON.stringify(t))}async hasCredentials(){try{const e=await this.storage.getItem(ys);if(!e)return!1;const t=JSON.parse(e);return!!t.encryptedCredentials||!!t.plaintextCredentials}catch{return!1}}async encryptCredentials(e,t){return async function(e,t){if(!t||0===t.trim().length)throw new Error("Passphrase is required for encryption");const s=(new TextEncoder).encode(e),r=crypto.getRandomValues(new Uint8Array(16)),n=crypto.getRandomValues(new Uint8Array(12)),a=await gs(t,r),o=await crypto.subtle.encrypt({name:ms,iv:n},a,s),i=new Uint8Array(28+o.byteLength);return i.set(r,0),i.set(n,16),i.set(new Uint8Array(o),28),btoa(String.fromCharCode(...i))}(JSON.stringify(e),t)}async decryptCredentials(e,t){const s=await async function(e,t){if(!t||0===t.trim().length)throw new Error("Passphrase is required for decryption");const s=Uint8Array.from(atob(e),e=>e.charCodeAt(0));if(s.length<28)throw new Error("Invalid encrypted data format");const r=s.slice(0,16),n=s.slice(16,28),a=s.slice(28),o=await gs(t,r);try{const e=await crypto.subtle.decrypt({name:ms,iv:n},o,a);return(new TextDecoder).decode(e)}catch(e){throw new Error("Decryption failed. Invalid passphrase or corrupted data.")}}(e,t);return JSON.parse(s)}async setModelForWeight(e,t){const s=await this.storage.getItem(ys);if(!s)throw new Error("No configuration found. Please configure the provider first.");const r=JSON.parse(s);r.models||(r.models={}),r.models[e]=t,await this.storage.setItem(ys,JSON.stringify(r))}async getModelForWeight(e){const t=await this.storage.getItem(ys);if(!t)return;const s=JSON.parse(t);return s.models?.[e]}async setUseDefaultModels(e){const t=await this.storage.getItem(ys);if(!t)throw new Error("No configuration found. Please configure the provider first.");const s=JSON.parse(t);s.useDefaultModels=e,await this.storage.setItem(ys,JSON.stringify(s))}async getUseDefaultModels(){const e=await this.storage.getItem(ys);return!!e&&(JSON.parse(e).useDefaultModels??!1)}async saveMetadata(e,t,s=!0){const r={provider:e,models:t,useDefaultModels:s,enableCache:!1,cacheTTL:bs,trackUsage:!1,version:ws};try{await this.storage.setItem(ys,JSON.stringify(r))}catch(e){throw new Error(`Failed to save configuration: ${e?.message||"Unknown error"}`)}}async saveLocal(e,t,s=!1){const r={provider:e.provider,models:e.models,useDefaultModels:s,enableCache:e.enableCache??!1,cacheTTL:e.cacheTTL??bs,trackUsage:e.trackUsage??!1,forceLocalMode:!0,version:ws};e.credentials&&(t&&t.trim().length>0?r.encryptedCredentials=await this.encryptCredentials(e.credentials,t):r.plaintextCredentials=JSON.stringify(e.credentials));try{await this.storage.setItem(ys,JSON.stringify(r))}catch(e){throw new Error(`Failed to save configuration: ${e?.message||"Unknown error"}`)}}async getPlaintextCredentials(){try{const e=await this.storage.getItem(ys);if(!e)return null;const t=JSON.parse(e);return t.plaintextCredentials?JSON.parse(t.plaintextCredentials):null}catch{return null}}async hasPlaintextCredentials(){try{const e=await this.storage.getItem(ys);return!!e&&!!JSON.parse(e).plaintextCredentials}catch{return!1}}async getForceLocalMode(){try{const e=await this.storage.getItem(ys);return!!e&&(JSON.parse(e).forceLocalMode??!1)}catch{return!1}}async setForceLocalMode(e){const t=await this.storage.getItem(ys);if(!t){const t={provider:"anthropic",useDefaultModels:!0,enableCache:!1,cacheTTL:bs,trackUsage:!1,forceLocalMode:e,version:ws};return void await this.storage.setItem(ys,JSON.stringify(t))}const s=JSON.parse(t);s.forceLocalMode=e,await this.storage.setItem(ys,JSON.stringify(s))}}(xs),As=new class{constructor(e){this.pendingConflicts=new Map,this.store=e??new _s,this.templateEngine=new Rs}async registerPrompt(e){const{name:t,version:s,prompt:r}=e;this.templateEngine.validateDefinition(r);const n=await this.store.get(t);if(!n){const e=_s.createStoredPrompt(t,s,r);return await this.store.put(e),console.log(`[PromptManager] Created prompt "${t}" v${s}`),{status:"created",prompt:e}}const a=function(e,t){const s=e.split(".").map(Number),r=t.split(".").map(Number);for(let e=0;e<Math.max(s.length,r.length);e++){const t=s[e]??0,n=r[e]??0;if(t<n)return-1;if(t>n)return 1}return 0}(s,n.version);if(0===a)return console.log(`[PromptManager] Prompt "${t}" unchanged (v${s})`),{status:"unchanged",prompt:n};if(a<0)return console.log(`[PromptManager] Prompt "${t}" not downgraded (v${n.version} > v${s})`),{status:"unchanged",prompt:n};if(!n.locallyModified){const e=n.version,a={...r,name:t,version:s,locallyModified:!1,createdAt:n.createdAt,updatedAt:(new Date).toISOString()};return await this.store.put(a),console.log(`[PromptManager] Auto-updated "${t}" v${e} -> v${s}`),{status:"updated",prompt:a,previousVersion:e}}const o={name:t,localVersion:n.version,upstreamVersion:s,localPrompt:n,upstreamPrompt:r};return this.pendingConflicts.set(t,o),console.log(`[PromptManager] Version conflict for "${t}": local v${n.version} (modified) vs upstream v${s}`),{status:"conflict",conflict:o}}async registerPrompts(e){const t=[];for(const s of e){const e=await this.registerPrompt(s);t.push(e)}return t}async getPrompt(e){return this.store.get(e)}async listPrompts(){return this.store.list()}async updatePrompt(e,t){this.templateEngine.validateDefinition(t);const s=await this.store.get(e);if(!s)throw new Error(`Prompt "${e}" not found`);const r={...t,name:e,version:s.version,locallyModified:!0,upstreamVersion:s.locallyModified?s.upstreamVersion:s.version,upstreamTemplate:s.locallyModified?s.upstreamTemplate:s.template,upstreamWeight:s.locallyModified?s.upstreamWeight:s.weight,createdAt:s.createdAt,updatedAt:(new Date).toISOString()};await this.store.put(r),console.log(`[PromptManager] User modified prompt "${e}"`)}async deletePrompt(e){await this.store.delete(e),this.pendingConflicts.delete(e),console.log(`[PromptManager] Deleted prompt "${e}"`)}async resolveConflict(e,t,s,r){const n=await this.store.get(e);if(!n)throw new Error(`Prompt "${e}" not found`);if("local"===t){const t={...n,upstreamVersion:r,upstreamTemplate:s.template,updatedAt:(new Date).toISOString()};await this.store.put(t),console.log(`[PromptManager] Conflict resolved for "${e}": kept local version`)}else{const t={...s,name:e,version:r,locallyModified:!1,upstreamVersion:void 0,upstreamTemplate:void 0,createdAt:n.createdAt,updatedAt:(new Date).toISOString()};await this.store.put(t),console.log(`[PromptManager] Conflict resolved for "${e}": accepted upstream v${r}`)}this.pendingConflicts.delete(e)}async resetToUpstream(e){const t=await this.store.get(e);if(!t)throw new Error(`Prompt "${e}" not found`);if(!t.locallyModified||!t.upstreamTemplate)throw new Error(`Prompt "${e}" has no original version to reset to`);const s={...t,template:t.upstreamTemplate,weight:t.upstreamWeight,locallyModified:!1,upstreamVersion:void 0,upstreamTemplate:void 0,upstreamWeight:void 0,updatedAt:(new Date).toISOString()};await this.store.put(s),console.log(`[PromptManager] Reset prompt "${e}" to upstream version`)}async renderPrompt(e,t){const s=await this.store.get(e);if(!s)throw new Error(`Prompt "${e}" not found`);const r=this.templateEngine.render(s.template,s.params??{},t??{});return{role:s.role??"user",content:r,expect_tags:s.expect_tags,weight:s.weight,promptName:e}}getPendingConflict(e){return this.pendingConflicts.get(e)}hasPendingConflicts(){return this.pendingConflicts.size>0}getPendingConflicts(){return Array.from(this.pendingConflicts.values())}};let Cs=null,Is=!1;function Os(e,t){Is||(Cs=ps.getInstance(Ts,e,t),Cs.setPromptHandler(Ds),Is=!0,console.log("[AI Delegate Worker] Initialized with credential server:",e||"(not configured)","allowLocalMode:",t))}function $s(){return Cs||Os(),Cs}const Ls=new Map;async function Ns(e,t){const s=fs.generateId();return new Promise((r,n)=>{Ls.set(s,{resolve:r,reject:n});const a={type:"prompt",promptType:e,requestId:s,data:t};self.postMessage(a),setTimeout(()=>{Ls.has(s)&&(Ls.delete(s),n(new Error("Prompt timeout - user did not respond")))},3e5)})}const Ds={async promptForConfiguration(){const e=await Ns(is.CONFIGURE),{password:t,useDefaultModels:s,...r}=e;return{config:r,password:t,useDefaultModels:s??!1}},promptForUnlock:async()=>await Ns(is.UNLOCK),promptForModelSelection:async(e,t)=>await Ns(is.MODEL_SELECT,{weight:e,availableModels:t}),promptForConflictResolution:async e=>await Ns(is.PROMPT_CONFLICT,e)};self.addEventListener("message",async e=>{const t=e.data;if("promptResponse"===t.type){const e=t,s=Ls.get(e.requestId);return void(s&&(Ls.delete(e.requestId),e.success?s.resolve(e.data):s.reject(new Error(e.error||"Prompt failed"))))}if(!fs.validateMessage(t)){const e=fs.createErrorResponse(t?.id||"unknown","Invalid message format");return void self.postMessage(e)}try{const e=await async function(e){const{id:t,command:s,payload:r}=e;switch(s){case os.INIT:return Os(r.credentialServerUrl,r.allowLocalMode),fs.createSuccessResponse(t);case os.CONFIGURE:return await $s().configure(r.config,r.password),fs.createSuccessResponse(t);case os.MAKE_REQUEST:r.options.stream&&(r.options.onStream=e=>{const s={type:"streamChunk",requestId:t,chunk:e};self.postMessage(s)});const e=await $s().makeRequest(r.options);if(r.options.stream){const e={type:"streamComplete",requestId:t};self.postMessage(e)}return fs.createSuccessResponse(t,e);case os.GET_STATUS:console.log("[Worker] GET_STATUS called, delegate initialized:",Is);const n=await $s().getStatus();return console.log("[Worker] GET_STATUS result:",n),fs.createSuccessResponse(t,n);case os.LOCK:return await $s().lock(),fs.createSuccessResponse(t);case os.RESET:return await $s().reset(),fs.createSuccessResponse(t);case os.UPDATE_CREDENTIALS:return await $s().updateCredentials(r.credentials,r.password),fs.createSuccessResponse(t);case os.IS_READY:const a=await $s().isReady();return fs.createSuccessResponse(t,a);case os.UNLOCK:return await $s().unlock(r.password),fs.createSuccessResponse(t);case os.GET_SETUP_URL:const o=$s().getCredentialServerSetupUrl();return fs.createSuccessResponse(t,o);case os.FETCH_MODELS:const i=await $s().fetchAvailableModels();return fs.createSuccessResponse(t,i);case os.SET_LOCAL_MODE:return await $s().setForceLocalMode(r.enabled),fs.createSuccessResponse(t);case os.IS_LOCAL_MODE_ALLOWED:const c=$s().isLocalModeAllowed();return fs.createSuccessResponse(t,c);case os.IS_LOCAL_MODE_FORCED:const l=$s().isLocalModeForced();return fs.createSuccessResponse(t,l);case os.CONFIGURE_LOCAL:console.log("[Worker] CONFIGURE_LOCAL received:",{config:r.config,hasPassword:!!r.password,useDefaultModels:r.useDefaultModels});try{return await $s().configureLocal(r.config,r.password,r.useDefaultModels??!0),console.log("[Worker] CONFIGURE_LOCAL completed successfully"),fs.createSuccessResponse(t)}catch(e){throw console.error("[Worker] CONFIGURE_LOCAL error:",e,e.message,e.stack),e}case os.REGISTER_PROMPT:{const e=await As.registerPrompt(r.registration);if("conflict"===e.status){const s=await Ds.promptForConflictResolution(e.conflict);await As.resolveConflict(e.conflict.name,s,e.conflict.upstreamPrompt,e.conflict.upstreamVersion);const r=await As.getPrompt(e.conflict.name);return"upstream"===s?fs.createSuccessResponse(t,{status:"updated",prompt:r,previousVersion:e.conflict.localVersion}):fs.createSuccessResponse(t,{status:"unchanged",prompt:r})}return fs.createSuccessResponse(t,e)}case os.REGISTER_PROMPTS:{const e=[];for(const t of r.registrations){const s=await As.registerPrompt(t);if("conflict"===s.status){const t=await Ds.promptForConflictResolution(s.conflict);await As.resolveConflict(s.conflict.name,t,s.conflict.upstreamPrompt,s.conflict.upstreamVersion);const r=await As.getPrompt(s.conflict.name);"upstream"===t?e.push({status:"updated",prompt:r,previousVersion:s.conflict.localVersion}):e.push({status:"unchanged",prompt:r})}else e.push(s)}return fs.createSuccessResponse(t,e)}case os.GET_PROMPT:{const e=await As.getPrompt(r.name);return fs.createSuccessResponse(t,e)}case os.LIST_PROMPTS:{const e=await As.listPrompts();return fs.createSuccessResponse(t,e)}case os.UPDATE_PROMPT:return await As.updatePrompt(r.name,r.prompt),fs.createSuccessResponse(t);case os.DELETE_PROMPT:return await As.deletePrompt(r.name),fs.createSuccessResponse(t);case os.RESET_PROMPT:return await As.resetToUpstream(r.name),fs.createSuccessResponse(t);case os.RESOLVE_CONFLICT:return await As.resolveConflict(r.name,r.choice,r.upstreamPrompt,r.upstreamVersion),fs.createSuccessResponse(t);case os.RENDER_PROMPT:{const e=await As.renderPrompt(r.name,r.params);return fs.createSuccessResponse(t,e)}default:throw new Error(`Unknown command: ${s}`)}}(t);self.postMessage(e)}catch(e){const s=fs.createErrorResponse(t.id,e);self.postMessage(s)}}),console.log("[AI Delegate Worker] Ready to receive commands")})();
//# sourceMappingURL=ai-delegate-worker.js.map'; + +/** + * Decode the base64-encoded worker source. + */ +function decodeWorkerSource(): string { + // Use atob for browser environment + if (typeof atob === 'function') { + return atob(EMBEDDED_WORKER_BASE64); + } + // Fallback for Node.js environment (for testing) + return Buffer.from(EMBEDDED_WORKER_BASE64, 'base64').toString('utf8'); +} + +/** + * The worker source code as a string. + * Lazily decoded on first access. + */ +let _cachedSource: string | null = null; +export function getWorkerSource(): string { + if (_cachedSource === null) { + _cachedSource = decodeWorkerSource(); + } + return _cachedSource; +} + +/** + * Creates a Blob URL for the embedded worker. + * The URL should be revoked with URL.revokeObjectURL() when no longer needed. + */ +export function createWorkerBlobUrl(): string { + const source = getWorkerSource(); + const blob = new Blob([source], { type: 'application/javascript' }); + return URL.createObjectURL(blob); +} + +/** + * Version marker to help with debugging cache issues. + * This is extracted from the worker bundle if present. + */ +export const EMBEDDED_WORKER_VERSION: string = '0.3.4'; diff --git a/src/worker/worker.ts b/src/worker/worker.ts index 7738e53..720eb02 100644 --- a/src/worker/worker.ts +++ b/src/worker/worker.ts @@ -13,8 +13,11 @@ import { PromptConflict } from '../types/prompts'; * Credentials and sensitive data NEVER leave this context */ +// Version injected by webpack DefinePlugin from package.json +declare const __AI_DELEGATE_VERSION__: string; + // Version marker for debugging cache issues -console.log('[AI Delegate Worker] Version: 0.3.2'); +console.log(`[AI Delegate Worker] Version: ${__AI_DELEGATE_VERSION__}`); // Storage and config manager (initialized immediately) const storage = new IndexedDBAdapter(); diff --git a/webpack.main.config.js b/webpack.main.config.js new file mode 100644 index 0000000..f48cd41 --- /dev/null +++ b/webpack.main.config.js @@ -0,0 +1,111 @@ +/** + * Webpack config for building the main bundle, server, and credential-server. + * This is built after the worker bundle and embed-worker script have run. + */ +const path = require('path'); + +module.exports = [ + // Main bundle (for the browser/main thread) + { + entry: './src/index.ts', + output: { + filename: 'ai-delegate.js', + path: path.resolve(__dirname, 'dist'), + library: { + name: 'AiDelegate', + type: 'umd', + export: 'default' + }, + globalObject: 'this' + }, + resolve: { + extensions: ['.ts', '.js'] + }, + module: { + rules: [ + { + test: /\.ts$/, + use: 'ts-loader', + exclude: /node_modules/ + } + ] + }, + optimization: { + minimize: true + }, + devtool: 'source-map' + }, + // Server bundle (for Node.js) + { + entry: './src/server/index.ts', + output: { + filename: 'server/index.js', + path: path.resolve(__dirname, 'dist'), + library: { + type: 'commonjs2' + } + }, + target: 'node', + externals: { + // Don't bundle Node.js built-in modules + fs: 'commonjs fs', + path: 'commonjs path', + http: 'commonjs http', + 'better-sqlite3': 'commonjs better-sqlite3' + }, + resolve: { + extensions: ['.ts', '.js'] + }, + module: { + rules: [ + { + test: /\.ts$/, + use: 'ts-loader', + exclude: /node_modules/ + } + ] + }, + optimization: { + minimize: false // Don't minimize server code for easier debugging + }, + devtool: 'source-map' + }, + // Credential Server bundle (for Node.js) + { + entry: './src/credential-server/index.ts', + output: { + filename: 'credential-server/index.js', + path: path.resolve(__dirname, 'dist'), + library: { + type: 'commonjs2' + } + }, + target: 'node', + externals: { + // Don't bundle Node.js built-in modules + fs: 'commonjs fs', + path: 'commonjs path', + http: 'commonjs http', + https: 'commonjs https', + crypto: 'commonjs crypto', + url: 'commonjs url', + 'better-sqlite3': 'commonjs better-sqlite3' + }, + resolve: { + extensions: ['.ts', '.js'] + }, + module: { + rules: [ + { + test: /\.ts$/, + use: 'ts-loader', + exclude: /node_modules/ + } + ] + }, + optimization: { + minimize: false // Don't minimize server code for easier debugging + }, + devtool: 'source-map' + } +]; diff --git a/webpack.worker.config.js b/webpack.worker.config.js new file mode 100644 index 0000000..ceabb10 --- /dev/null +++ b/webpack.worker.config.js @@ -0,0 +1,38 @@ +/** + * Webpack config for building the worker bundle. + * This is built first, before the main bundle. + */ +const path = require('path'); +const webpack = require('webpack'); +const packageJson = require('./package.json'); + +module.exports = { + entry: './src/worker-entry.ts', + output: { + filename: 'ai-delegate-worker.js', + path: path.resolve(__dirname, 'dist'), + globalObject: 'self' // Important: use 'self' for worker context + }, + target: 'webworker', // Target web worker environment + resolve: { + extensions: ['.ts', '.js'] + }, + module: { + rules: [ + { + test: /\.ts$/, + use: 'ts-loader', + exclude: /node_modules/ + } + ] + }, + optimization: { + minimize: true + }, + plugins: [ + new webpack.DefinePlugin({ + __AI_DELEGATE_VERSION__: JSON.stringify(packageJson.version) + }) + ], + devtool: 'source-map' +}; -- GitLab From f5777ed8bf75bdfb84c46e4a12792408b282ecad Mon Sep 17 00:00:00 2001 From: Lembot Date: Fri, 9 Jan 2026 17:47:47 -0500 Subject: [PATCH 2/3] chore: gitignore generated embedded-worker.ts Per review feedback, remove the generated embedded-worker.ts from version control and add it to .gitignore. Users will generate it on build. Co-Authored-By: Claude Opus 4.5 --- .gitignore | 3 ++ src/worker/embedded-worker.ts | 53 ----------------------------------- 2 files changed, 3 insertions(+), 53 deletions(-) delete mode 100644 src/worker/embedded-worker.ts diff --git a/.gitignore b/.gitignore index 73632f4..2188385 100644 --- a/.gitignore +++ b/.gitignore @@ -4,5 +4,8 @@ node_modules/ # Build output dist/ +# Generated files +src/worker/embedded-worker.ts + # Credential database (contains encrypted API keys) credentials.db diff --git a/src/worker/embedded-worker.ts b/src/worker/embedded-worker.ts deleted file mode 100644 index dd61196..0000000 --- a/src/worker/embedded-worker.ts +++ /dev/null @@ -1,53 +0,0 @@ -/** - * AUTO-GENERATED FILE - DO NOT EDIT - * - * This file contains the embedded worker bundle for inline worker creation. - * Generated by scripts/embed-worker.js - * - * To regenerate: npm run build:worker && npm run embed-worker - */ - -/** - * The worker source code as a base64-encoded string. - */ -const EMBEDDED_WORKER_BASE64 = '(()=>{"use strict";class e{constructor(e,t){this.provider=e,this.modelMapping=t||{}}getModel(e){return this.modelMapping[e]}getMapping(){return{...this.modelMapping}}setModel(e,t){this.modelMapping[e]=t}updateMapping(e){this.modelMapping={...this.modelMapping,...e}}resetToDefaults(){this.modelMapping={}}clear(){this.modelMapping={}}validate(){return"string"==typeof this.modelMapping.light&&this.modelMapping.light.length>0&&"string"==typeof this.modelMapping.moderate&&this.modelMapping.moderate.length>0&&"string"==typeof this.modelMapping.heavy&&this.modelMapping.heavy.length>0}getProvider(){return this.provider}setProvider(e){this.provider=e,this.resetToDefaults()}}function t(e,t,s,r,n){if("m"===r)throw new TypeError("Private method is not writable");if("a"===r&&!n)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof t?e!==t||!n:!t.has(e))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===r?n.call(e,s):n?n.value=s:t.set(e,s),s}function s(e,t,s,r){if("a"===s&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof t?e!==t||!r:!t.has(e))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===s?r:"a"===s?r.call(e):r?r.value:t.get(e)}let r=function(){const{crypto:e}=globalThis;if(e?.randomUUID)return r=e.randomUUID.bind(e),e.randomUUID();const t=new Uint8Array(1),s=e?()=>e.getRandomValues(t)[0]:()=>255*Math.random()&255;return"10000000-1000-4000-8000-100000000000".replace(/[018]/g,e=>(+e^s()&15>>+e/4).toString(16))};function n(e){return"object"==typeof e&&null!==e&&("name"in e&&"AbortError"===e.name||"message"in e&&String(e.message).includes("FetchRequestCanceledException"))}const a=e=>{if(e instanceof Error)return e;if("object"==typeof e&&null!==e){try{if("[object Error]"===Object.prototype.toString.call(e)){const t=new Error(e.message,e.cause?{cause:e.cause}:{});return e.stack&&(t.stack=e.stack),e.cause&&!t.cause&&(t.cause=e.cause),e.name&&(t.name=e.name),t}}catch{}try{return new Error(JSON.stringify(e))}catch{}}return new Error(e)};class o extends Error{}class i extends o{constructor(e,t,s,r){super(`${i.makeMessage(e,t,s)}`),this.status=e,this.headers=r,this.requestID=r?.get("request-id"),this.error=t}static makeMessage(e,t,s){const r=t?.message?"string"==typeof t.message?t.message:JSON.stringify(t.message):t?JSON.stringify(t):s;return e&&r?`${e} ${r}`:e?`${e} status code (no body)`:r||"(no status code or body)"}static generate(e,t,s,r){if(!e||!r)return new l({message:s,cause:a(t)});const n=t;return 400===e?new h(e,n,s,r):401===e?new u(e,n,s,r):403===e?new p(e,n,s,r):404===e?new f(e,n,s,r):409===e?new m(e,n,s,r):422===e?new g(e,n,s,r):429===e?new w(e,n,s,r):e>=500?new y(e,n,s,r):new i(e,n,s,r)}}class c extends i{constructor({message:e}={}){super(void 0,void 0,e||"Request was aborted.",void 0)}}class l extends i{constructor({message:e,cause:t}){super(void 0,void 0,e||"Connection error.",void 0),t&&(this.cause=t)}}class d extends l{constructor({message:e}={}){super({message:e??"Request timed out."})}}class h extends i{}class u extends i{}class p extends i{}class f extends i{}class m extends i{}class g extends i{}class w extends i{}class y extends i{}const b=/^[a-z][a-z0-9+.-]*:/i;let v=e=>(v=Array.isArray,v(e)),_=v;function k(e){return"object"!=typeof e?{}:e??{}}const S=e=>{try{return JSON.parse(e)}catch(e){return}},M="0.71.0",P=()=>{const e="undefined"!=typeof Deno&&null!=Deno.build?"deno":"undefined"!=typeof EdgeRuntime?"edge":"[object process]"===Object.prototype.toString.call(void 0!==globalThis.process?globalThis.process:0)?"node":"unknown";if("deno"===e)return{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":R(Deno.build.os),"X-Stainless-Arch":E(Deno.build.arch),"X-Stainless-Runtime":"deno","X-Stainless-Runtime-Version":"string"==typeof Deno.version?Deno.version:Deno.version?.deno??"unknown"};if("undefined"!=typeof EdgeRuntime)return{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":"Unknown","X-Stainless-Arch":`other:${EdgeRuntime}`,"X-Stainless-Runtime":"edge","X-Stainless-Runtime-Version":globalThis.process.version};if("node"===e)return{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":R(globalThis.process.platform??"unknown"),"X-Stainless-Arch":E(globalThis.process.arch??"unknown"),"X-Stainless-Runtime":"node","X-Stainless-Runtime-Version":globalThis.process.version??"unknown"};const t=function(){if("undefined"==typeof navigator||!navigator)return null;const e=[{key:"edge",pattern:/Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"ie",pattern:/MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"ie",pattern:/Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"chrome",pattern:/Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"firefox",pattern:/Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/},{key:"safari",pattern:/(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/}];for(const{key:t,pattern:s}of e){const e=s.exec(navigator.userAgent);if(e)return{browser:t,version:`${e[1]||0}.${e[2]||0}.${e[3]||0}`}}return null}();return t?{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":"Unknown","X-Stainless-Arch":"unknown","X-Stainless-Runtime":`browser:${t.browser}`,"X-Stainless-Runtime-Version":t.version}:{"X-Stainless-Lang":"js","X-Stainless-Package-Version":M,"X-Stainless-OS":"Unknown","X-Stainless-Arch":"unknown","X-Stainless-Runtime":"unknown","X-Stainless-Runtime-Version":"unknown"}},E=e=>"x32"===e?"x32":"x86_64"===e||"x64"===e?"x64":"arm"===e?"arm":"aarch64"===e||"arm64"===e?"arm64":e?`other:${e}`:"unknown",R=e=>(e=e.toLowerCase()).includes("ios")?"iOS":"android"===e?"Android":"darwin"===e?"MacOS":"win32"===e?"Windows":"freebsd"===e?"FreeBSD":"openbsd"===e?"OpenBSD":"linux"===e?"Linux":e?`Other:${e}`:"Unknown";let x;function T(...e){const t=globalThis.ReadableStream;if(void 0===t)throw new Error("`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`");return new t(...e)}function A(e){let t=Symbol.asyncIterator in e?e[Symbol.asyncIterator]():e[Symbol.iterator]();return T({start(){},async pull(e){const{done:s,value:r}=await t.next();s?e.close():e.enqueue(r)},async cancel(){await(t.return?.())}})}function C(e){if(e[Symbol.asyncIterator])return e;const t=e.getReader();return{async next(){try{const e=await t.read();return e?.done&&t.releaseLock(),e}catch(e){throw t.releaseLock(),e}},async return(){const e=t.cancel();return t.releaseLock(),await e,{done:!0,value:void 0}},[Symbol.asyncIterator](){return this}}}const I=({headers:e,body:t})=>({bodyHeaders:{"content-type":"application/json"},body:JSON.stringify(t)});let O,$;function L(e){let t;return(O??(t=new globalThis.TextEncoder,O=t.encode.bind(t)))(e)}function N(e){let t;return($??(t=new globalThis.TextDecoder,$=t.decode.bind(t)))(e)}var D,U;class q{constructor(){D.set(this,void 0),U.set(this,void 0),t(this,D,new Uint8Array,"f"),t(this,U,null,"f")}decode(e){if(null==e)return[];const r=e instanceof ArrayBuffer?new Uint8Array(e):"string"==typeof e?L(e):e;t(this,D,function(e){let t=0;for(const s of e)t+=s.length;const s=new Uint8Array(t);let r=0;for(const t of e)s.set(t,r),r+=t.length;return s}([s(this,D,"f"),r]),"f");const n=[];let a;for(;null!=(a=j(s(this,D,"f"),s(this,U,"f")));){if(a.carriage&&null==s(this,U,"f")){t(this,U,a.index,"f");continue}if(null!=s(this,U,"f")&&(a.index!==s(this,U,"f")+1||a.carriage)){n.push(N(s(this,D,"f").subarray(0,s(this,U,"f")-1))),t(this,D,s(this,D,"f").subarray(s(this,U,"f")),"f"),t(this,U,null,"f");continue}const e=null!==s(this,U,"f")?a.preceding-1:a.preceding,r=N(s(this,D,"f").subarray(0,e));n.push(r),t(this,D,s(this,D,"f").subarray(a.index),"f"),t(this,U,null,"f")}return n}flush(){return s(this,D,"f").length?this.decode("\n"):[]}}function j(e,t){for(let s=t??0;s<e.length;s++){if(10===e[s])return{preceding:s,index:s+1,carriage:!1};if(13===e[s])return{preceding:s,index:s+1,carriage:!0}}return null}function F(e){for(let t=0;t<e.length-1;t++){if(10===e[t]&&10===e[t+1])return t+2;if(13===e[t]&&13===e[t+1])return t+2;if(13===e[t]&&10===e[t+1]&&t+3<e.length&&13===e[t+2]&&10===e[t+3])return t+4}return-1}D=new WeakMap,U=new WeakMap,q.NEWLINE_CHARS=new Set(["\n","\r"]),q.NEWLINE_REGEXP=/\r\n|[\n\r]/g;const W={off:0,error:200,warn:300,info:400,debug:500},B=(e,t,s)=>{var r,n;if(e)return r=W,n=e,Object.prototype.hasOwnProperty.call(r,n)?e:void V(s).warn(`${t} was set to ${JSON.stringify(e)}, expected one of ${JSON.stringify(Object.keys(W))}`)};function J(){}function z(e,t,s){return!t||W[e]>W[s]?J:t[e].bind(t)}const H={error:J,warn:J,info:J,debug:J};let K=new WeakMap;function V(e){const t=e.logger,s=e.logLevel??"off";if(!t)return H;const r=K.get(t);if(r&&r[0]===s)return r[1];const n={error:z("error",t,s),warn:z("warn",t,s),info:z("info",t,s),debug:z("debug",t,s)};return K.set(t,[s,n]),n}const X=e=>(e.options&&(e.options={...e.options},delete e.options.headers),e.headers&&(e.headers=Object.fromEntries((e.headers instanceof Headers?[...e.headers]:Object.entries(e.headers)).map(([e,t])=>[e,"x-api-key"===e.toLowerCase()||"authorization"===e.toLowerCase()||"cookie"===e.toLowerCase()||"set-cookie"===e.toLowerCase()?"***":t]))),"retryOfRequestLogID"in e&&(e.retryOfRequestLogID&&(e.retryOf=e.retryOfRequestLogID),delete e.retryOfRequestLogID),e);var G,Y,Q;class Z{constructor(e,s,r){this.iterator=e,G.set(this,void 0),this.controller=s,t(this,G,r,"f")}static fromSSEResponse(e,t,s){let r=!1;const a=s?V(s):console;return new Z(async function*(){if(r)throw new o("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");r=!0;let s=!1;try{for await(const s of async function*(e,t){if(!e.body){if(t.abort(),void 0!==globalThis.navigator&&"ReactNative"===globalThis.navigator.product)throw new o("The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api");throw new o("Attempted to iterate over a response with no body")}const s=new ee,r=new q,n=C(e.body);for await(const e of async function*(e){let t=new Uint8Array;for await(const s of e){if(null==s)continue;const e=s instanceof ArrayBuffer?new Uint8Array(s):"string"==typeof s?L(s):s;let r,n=new Uint8Array(t.length+e.length);for(n.set(t),n.set(e,t.length),t=n;-1!==(r=F(t));)yield t.slice(0,r),t=t.slice(r)}t.length>0&&(yield t)}(n))for(const t of r.decode(e)){const e=s.decode(t);e&&(yield e)}for(const e of r.flush()){const t=s.decode(e);t&&(yield t)}}(e,t)){if("completion"===s.event)try{yield JSON.parse(s.data)}catch(e){throw a.error("Could not parse message into JSON:",s.data),a.error("From chunk:",s.raw),e}if("message_start"===s.event||"message_delta"===s.event||"message_stop"===s.event||"content_block_start"===s.event||"content_block_delta"===s.event||"content_block_stop"===s.event)try{yield JSON.parse(s.data)}catch(e){throw a.error("Could not parse message into JSON:",s.data),a.error("From chunk:",s.raw),e}if("ping"!==s.event&&"error"===s.event)throw new i(void 0,S(s.data)??s.data,void 0,e.headers)}s=!0}catch(e){if(n(e))return;throw e}finally{s||t.abort()}},t,s)}static fromReadableStream(e,t,s){let r=!1;return new Z(async function*(){if(r)throw new o("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");r=!0;let s=!1;try{for await(const t of async function*(){const t=new q,s=C(e);for await(const e of s)for(const s of t.decode(e))yield s;for(const e of t.flush())yield e}())s||t&&(yield JSON.parse(t));s=!0}catch(e){if(n(e))return;throw e}finally{s||t.abort()}},t,s)}[(G=new WeakMap,Symbol.asyncIterator)](){return this.iterator()}tee(){const e=[],t=[],r=this.iterator(),n=s=>({next:()=>{if(0===s.length){const s=r.next();e.push(s),t.push(s)}return s.shift()}});return[new Z(()=>n(e),this.controller,s(this,G,"f")),new Z(()=>n(t),this.controller,s(this,G,"f"))]}toReadableStream(){const e=this;let t;return T({async start(){t=e[Symbol.asyncIterator]()},async pull(e){try{const{value:s,done:r}=await t.next();if(r)return e.close();const n=L(JSON.stringify(s)+"\n");e.enqueue(n)}catch(t){e.error(t)}},async cancel(){await(t.return?.())}})}}class ee{constructor(){this.event=null,this.data=[],this.chunks=[]}decode(e){if(e.endsWith("\r")&&(e=e.substring(0,e.length-1)),!e){if(!this.event&&!this.data.length)return null;const e={event:this.event,data:this.data.join("\n"),raw:this.chunks};return this.event=null,this.data=[],this.chunks=[],e}if(this.chunks.push(e),e.startsWith(":"))return null;let[t,s,r]=function(e){const t=e.indexOf(":");return-1!==t?[e.substring(0,t),":",e.substring(t+1)]:[e,"",""]}(e);return r.startsWith(" ")&&(r=r.substring(1)),"event"===t?this.event=r:"data"===t&&this.data.push(r),null}}async function te(e,t){const{response:s,requestLogID:r,retryOfRequestLogID:n,startTime:a}=t,o=await(async()=>{if(t.options.stream)return V(e).debug("response",s.status,s.url,s.headers,s.body),t.options.__streamClass?t.options.__streamClass.fromSSEResponse(s,t.controller):Z.fromSSEResponse(s,t.controller);if(204===s.status)return null;if(t.options.__binaryResponse)return s;const r=s.headers.get("content-type"),n=r?.split(";")[0]?.trim();return n?.includes("application/json")||n?.endsWith("+json")?se(await s.json(),s):await s.text()})();return V(e).debug(`[${r}] response parsed`,X({retryOfRequestLogID:n,url:s.url,status:s.status,body:o,durationMs:Date.now()-a})),o}function se(e,t){return!e||"object"!=typeof e||Array.isArray(e)?e:Object.defineProperty(e,"_request_id",{value:t.headers.get("request-id"),enumerable:!1})}class re extends Promise{constructor(e,s,r=te){super(e=>{e(null)}),this.responsePromise=s,this.parseResponse=r,Y.set(this,void 0),t(this,Y,e,"f")}_thenUnwrap(e){return new re(s(this,Y,"f"),this.responsePromise,async(t,s)=>se(e(await this.parseResponse(t,s),s),s.response))}asResponse(){return this.responsePromise.then(e=>e.response)}async withResponse(){const[e,t]=await Promise.all([this.parse(),this.asResponse()]);return{data:e,response:t,request_id:t.headers.get("request-id")}}parse(){return this.parsedPromise||(this.parsedPromise=this.responsePromise.then(e=>this.parseResponse(s(this,Y,"f"),e))),this.parsedPromise}then(e,t){return this.parse().then(e,t)}catch(e){return this.parse().catch(e)}finally(e){return this.parse().finally(e)}}Y=new WeakMap;class ne{constructor(e,s,r,n){Q.set(this,void 0),t(this,Q,e,"f"),this.options=n,this.response=s,this.body=r}hasNextPage(){return!!this.getPaginatedItems().length&&null!=this.nextPageRequestOptions()}async getNextPage(){const e=this.nextPageRequestOptions();if(!e)throw new o("No next page expected; please check `.hasNextPage()` before calling `.getNextPage()`.");return await s(this,Q,"f").requestAPIList(this.constructor,e)}async*iterPages(){let e=this;for(yield e;e.hasNextPage();)e=await e.getNextPage(),yield e}async*[(Q=new WeakMap,Symbol.asyncIterator)](){for await(const e of this.iterPages())for(const t of e.getPaginatedItems())yield t}}class ae extends re{constructor(e,t,s){super(e,t,async(e,t)=>new s(e,t.response,await te(e,t),t.options))}async*[Symbol.asyncIterator](){const e=await(this);for await(const t of e)yield t}}class oe extends ne{constructor(e,t,s,r){super(e,t,s,r),this.data=s.data||[],this.has_more=s.has_more||!1,this.first_id=s.first_id||null,this.last_id=s.last_id||null}getPaginatedItems(){return this.data??[]}hasNextPage(){return!1!==this.has_more&&super.hasNextPage()}nextPageRequestOptions(){if(this.options.query?.before_id){const e=this.first_id;return e?{...this.options,query:{...k(this.options.query),before_id:e}}:null}const e=this.last_id;return e?{...this.options,query:{...k(this.options.query),after_id:e}}:null}}class ie extends ne{constructor(e,t,s,r){super(e,t,s,r),this.data=s.data||[],this.has_more=s.has_more||!1,this.next_page=s.next_page||null}getPaginatedItems(){return this.data??[]}hasNextPage(){return!1!==this.has_more&&super.hasNextPage()}nextPageRequestOptions(){const e=this.next_page;return e?{...this.options,query:{...k(this.options.query),page:e}}:null}}const ce=()=>{if("undefined"==typeof File){const{process:e}=globalThis,t="string"==typeof e?.versions?.node&&parseInt(e.versions.node.split("."))<20;throw new Error("`File` is not defined as a global, which is required for file uploads."+(t?" Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`.":""))}};function le(e,t,s){return ce(),new File(e,t??"unknown_file",s)}function de(e){return("object"==typeof e&&null!==e&&("name"in e&&e.name&&String(e.name)||"url"in e&&e.url&&String(e.url)||"filename"in e&&e.filename&&String(e.filename)||"path"in e&&e.path&&String(e.path))||"").split(/[\\/]/).pop()||void 0}const he=e=>null!=e&&"object"==typeof e&&"function"==typeof e[Symbol.asyncIterator],ue=async(e,t)=>({...e,body:await fe(e.body,t)}),pe=new WeakMap,fe=async(e,t)=>{if(!await function(e){const t="function"==typeof e?e:e.fetch,s=pe.get(t);if(s)return s;const r=(async()=>{try{const e="Response"in t?t.Response:(await t("data:,")).constructor,s=new FormData;return s.toString()!==await new e(s).text()}catch{return!0}})();return pe.set(t,r),r}(t))throw new TypeError("The provided fetch function does not support file uploads with the current global FormData class.");const s=new FormData;return await Promise.all(Object.entries(e||{}).map(([e,t])=>me(s,e,t))),s},me=async(e,t,s)=>{if(void 0!==s){if(null==s)throw new TypeError(`Received null for "${t}"; to pass null in FormData, you must use the string 'null'`);if("string"==typeof s||"number"==typeof s||"boolean"==typeof s)e.append(t,String(s));else if(s instanceof Response){let r={};const n=s.headers.get("Content-Type");n&&(r={type:n}),e.append(t,le([await s.blob()],de(s),r))}else if(he(s))e.append(t,le([await new Response(A(s)).blob()],de(s)));else if((e=>e instanceof Blob&&"name"in e)(s))e.append(t,le([s],de(s),{type:s.type}));else if(Array.isArray(s))await Promise.all(s.map(s=>me(e,t+"[]",s)));else{if("object"!=typeof s)throw new TypeError(`Invalid value given to form, expected a string, number, boolean, object, Array, File or Blob but got ${s} instead`);await Promise.all(Object.entries(s).map(([s,r])=>me(e,`${t}[${s}]`,r)))}}},ge=e=>null!=e&&"object"==typeof e&&"number"==typeof e.size&&"string"==typeof e.type&&"function"==typeof e.text&&"function"==typeof e.slice&&"function"==typeof e.arrayBuffer;async function we(e){let t=[];if("string"==typeof e||ArrayBuffer.isView(e)||e instanceof ArrayBuffer)t.push(e);else if(ge(e))t.push(e instanceof Blob?e:await e.arrayBuffer());else{if(!he(e)){const t=e?.constructor?.name;throw new Error(`Unexpected data type: ${typeof e}${t?`; constructor: ${t}`:""}${function(e){if("object"!=typeof e||null===e)return"";return`; props: [${Object.getOwnPropertyNames(e).map(e=>`"${e}"`).join(", ")}]`}(e)}`)}for await(const s of e)t.push(...await we(s))}return t}class ye{constructor(e){this._client=e}}const be=Symbol.for("brand.privateNullableHeaders");function*ve(e){if(!e)return;if(be in e){const{values:t,nulls:s}=e;yield*t.entries();for(const e of s)yield[e,null];return}let t,s=!1;e instanceof Headers?t=e.entries():_(e)?t=e:(s=!0,t=Object.entries(e??{}));for(let e of t){const t=e[0];if("string"!=typeof t)throw new TypeError("expected header name to be a string");const r=_(e[1])?e[1]:[e[1]];let n=!1;for(const e of r)void 0!==e&&(s&&!n&&(n=!0,yield[t,null]),yield[t,e])}}const _e=e=>{const t=new Headers,s=new Set;for(const r of e){const e=new Set;for(const[n,a]of ve(r)){const r=n.toLowerCase();e.has(r)||(t.delete(n),e.add(r)),null===a?(t.delete(n),s.add(r)):(t.append(n,a),s.delete(r))}}return{[be]:!0,values:t,nulls:s}};function ke(e){return e.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g,encodeURIComponent)}const Se=Object.freeze(Object.create(null)),Me=(e=ke)=>function(t,...s){if(1===t.length)return t[0];let r=!1;const n=[],a=t.reduce((t,a,o)=>{/[?#]/.test(a)&&(r=!0);const i=s[o];let c=(r?encodeURIComponent:e)(""+i);return o!==s.length&&(null==i||"object"==typeof i&&i.toString===Object.getPrototypeOf(Object.getPrototypeOf(i.hasOwnProperty??Se)??Se)?.toString)&&(c=i+"",n.push({start:t.length+a.length,length:c.length,error:`Value of type ${Object.prototype.toString.call(i).slice(8,-1)} is not a valid path parameter`})),t+a+(o===s.length?"":c)},""),i=a.split(/[?#]/,1)[0],c=/(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;let l;for(;null!==(l=c.exec(i));)n.push({start:l.index,length:l[0].length,error:`Value "${l[0]}" can't be safely passed as a path parameter`});if(n.sort((e,t)=>e.start-t.start),n.length>0){let e=0;const t=n.reduce((t,s)=>{const r=" ".repeat(s.start-e),n="^".repeat(s.length);return e=s.start+s.length,t+r+n},"");throw new o(`Path parameters result in path with invalid segments:\n${n.map(e=>e.error).join("\n")}\n${a}\n${t}`)}return a},Pe=Me(ke);class Ee extends ye{list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/files",oe,{query:r,...t,headers:_e([{"anthropic-beta":[...s??[],"files-api-2025-04-14"].toString()},t?.headers])})}delete(e,t={},s){const{betas:r}=t??{};return this._client.delete(Pe`/v1/files/${e}`,{...s,headers:_e([{"anthropic-beta":[...r??[],"files-api-2025-04-14"].toString()},s?.headers])})}download(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/files/${e}/content`,{...s,headers:_e([{"anthropic-beta":[...r??[],"files-api-2025-04-14"].toString(),Accept:"application/binary"},s?.headers]),__binaryResponse:!0})}retrieveMetadata(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/files/${e}`,{...s,headers:_e([{"anthropic-beta":[...r??[],"files-api-2025-04-14"].toString()},s?.headers])})}upload(e,t){const{betas:s,...r}=e;return this._client.post("/v1/files",ue({body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"files-api-2025-04-14"].toString()},t?.headers])},this._client))}}class Re extends ye{retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/models/${e}?beta=true`,{...s,headers:_e([{...null!=r?.toString()?{"anthropic-beta":r?.toString()}:void 0},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/models?beta=true",oe,{query:r,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers])})}}const xe={"claude-opus-4-20250514":8192,"claude-opus-4-0":8192,"claude-4-opus-20250514":8192,"anthropic.claude-opus-4-20250514-v1:0":8192,"claude-opus-4@20250514":8192,"claude-opus-4-1-20250805":8192,"anthropic.claude-opus-4-1-20250805-v1:0":8192,"claude-opus-4-1@20250805":8192};function Te(e,t){return t&&"parse"in(t.output_format??{})?Ae(e,t):{...e,content:e.content.map(e=>"text"===e.type?{...e,parsed:null}:e),parsed_output:null}}function Ae(e,t){let s=null;const r=e.content.map(e=>{if("text"===e.type){const r=function(e,t){if("json_schema"!==e.output_format?.type)return null;try{return"parse"in e.output_format?e.output_format.parse(t):JSON.parse(t)}catch(e){throw new o(`Failed to parse structured output: ${e}`)}}(t,e.text);return null===s&&(s=r),{...e,parsed:r}}return e});return{...e,content:r,parsed_output:s}}const Ce=e=>{if(0===e.length)return e;let t=e[e.length-1];switch(t.type){case"separator":return e=e.slice(0,e.length-1),Ce(e);case"number":let s=t.value[t.value.length-1];if("."===s||"-"===s)return e=e.slice(0,e.length-1),Ce(e);case"string":let r=e[e.length-2];if("delimiter"===r?.type)return e=e.slice(0,e.length-1),Ce(e);if("brace"===r?.type&&"{"===r.value)return e=e.slice(0,e.length-1),Ce(e);break;case"delimiter":return e=e.slice(0,e.length-1),Ce(e)}return e},Ie=e=>JSON.parse((e=>{let t="";return e.map(e=>{"string"===e.type?t+='"'+e.value+'"':t+=e.value}),t})((e=>{let t=[];return e.map(e=>{"brace"===e.type&&("{"===e.value?t.push("}"):t.splice(t.lastIndexOf("}"),1)),"paren"===e.type&&("["===e.value?t.push("]"):t.splice(t.lastIndexOf("]"),1))}),t.length>0&&t.reverse().map(t=>{"}"===t?e.push({type:"brace",value:"}"}):"]"===t&&e.push({type:"paren",value:"]"})}),e})(Ce((e=>{let t=0,s=[];for(;t<e.length;){let r=e[t];if("\\"===r){t++;continue}if("{"===r){s.push({type:"brace",value:"{"}),t++;continue}if("}"===r){s.push({type:"brace",value:"}"}),t++;continue}if("["===r){s.push({type:"paren",value:"["}),t++;continue}if("]"===r){s.push({type:"paren",value:"]"}),t++;continue}if(":"===r){s.push({type:"separator",value:":"}),t++;continue}if(","===r){s.push({type:"delimiter",value:","}),t++;continue}if('"'===r){let n="",a=!1;for(r=e[++t];'"'!==r;){if(t===e.length){a=!0;break}if("\\"===r){if(t++,t===e.length){a=!0;break}n+=r+e[t],r=e[++t]}else n+=r,r=e[++t]}r=e[++t],a||s.push({type:"string",value:n});continue}if(r&&/\s/.test(r)){t++;continue}let n=/[0-9]/;if(r&&n.test(r)||"-"===r||"."===r){let a="";for("-"===r&&(a+=r,r=e[++t]);r&&n.test(r)||"."===r;)a+=r,r=e[++t];s.push({type:"number",value:a});continue}let a=/[a-z]/i;if(r&&a.test(r)){let n="";for(;r&&a.test(r)&&t!==e.length;)n+=r,r=e[++t];if("true"!=n&&"false"!=n&&"null"!==n){t++;continue}s.push({type:"name",value:n});continue}t++}return s})(e)))));var Oe,$e,Le,Ne,De,Ue,qe,je,Fe,We,Be,Je,ze,He,Ke,Ve,Xe,Ge,Ye,Qe,Ze,et,tt;const st="__json_buf";function rt(e){return"tool_use"===e.type||"server_tool_use"===e.type||"mcp_tool_use"===e.type}class nt{constructor(e){Oe.add(this),this.messages=[],this.receivedMessages=[],$e.set(this,void 0),Le.set(this,null),this.controller=new AbortController,Ne.set(this,void 0),De.set(this,()=>{}),Ue.set(this,()=>{}),qe.set(this,void 0),je.set(this,()=>{}),Fe.set(this,()=>{}),We.set(this,{}),Be.set(this,!1),Je.set(this,!1),ze.set(this,!1),He.set(this,!1),Ke.set(this,void 0),Ve.set(this,void 0),Ye.set(this,e=>{if(t(this,Je,!0,"f"),n(e)&&(e=new c),e instanceof c)return t(this,ze,!0,"f"),this._emit("abort",e);if(e instanceof o)return this._emit("error",e);if(e instanceof Error){const t=new o(e.message);return t.cause=e,this._emit("error",t)}return this._emit("error",new o(String(e)))}),t(this,Ne,new Promise((e,s)=>{t(this,De,e,"f"),t(this,Ue,s,"f")}),"f"),t(this,qe,new Promise((e,s)=>{t(this,je,e,"f"),t(this,Fe,s,"f")}),"f"),s(this,Ne,"f").catch(()=>{}),s(this,qe,"f").catch(()=>{}),t(this,Le,e,"f")}get response(){return s(this,Ke,"f")}get request_id(){return s(this,Ve,"f")}async withResponse(){const e=await s(this,Ne,"f");if(!e)throw new Error("Could not resolve a `Response` object");return{data:this,response:e,request_id:e.headers.get("request-id")}}static fromReadableStream(e){const t=new nt(null);return t._run(()=>t._fromReadableStream(e)),t}static createMessage(e,s,r){const n=new nt(s);for(const e of s.messages)n._addMessageParam(e);return t(n,Le,{...s,stream:!0},"f"),n._run(()=>n._createMessage(e,{...s,stream:!0},{...r,headers:{...r?.headers,"X-Stainless-Helper-Method":"stream"}})),n}_run(e){e().then(()=>{this._emitFinal(),this._emit("end")},s(this,Ye,"f"))}_addMessageParam(e){this.messages.push(e)}_addMessage(e,t=!0){this.receivedMessages.push(e),t&&this._emit("message",e)}async _createMessage(e,t,r){const n=r?.signal;let a;n&&(n.aborted&&this.controller.abort(),a=this.controller.abort.bind(this.controller),n.addEventListener("abort",a));try{s(this,Oe,"m",Qe).call(this);const{response:n,data:a}=await e.create({...t,stream:!0},{...r,signal:this.controller.signal}).withResponse();this._connected(n);for await(const e of a)s(this,Oe,"m",Ze).call(this,e);if(a.controller.signal?.aborted)throw new c;s(this,Oe,"m",et).call(this)}finally{n&&a&&n.removeEventListener("abort",a)}}_connected(e){this.ended||(t(this,Ke,e,"f"),t(this,Ve,e?.headers.get("request-id"),"f"),s(this,De,"f").call(this,e),this._emit("connect"))}get ended(){return s(this,Be,"f")}get errored(){return s(this,Je,"f")}get aborted(){return s(this,ze,"f")}abort(){this.controller.abort()}on(e,t){return(s(this,We,"f")[e]||(s(this,We,"f")[e]=[])).push({listener:t}),this}off(e,t){const r=s(this,We,"f")[e];if(!r)return this;const n=r.findIndex(e=>e.listener===t);return n>=0&&r.splice(n,1),this}once(e,t){return(s(this,We,"f")[e]||(s(this,We,"f")[e]=[])).push({listener:t,once:!0}),this}emitted(e){return new Promise((s,r)=>{t(this,He,!0,"f"),"error"!==e&&this.once("error",r),this.once(e,s)})}async done(){t(this,He,!0,"f"),await s(this,qe,"f")}get currentMessage(){return s(this,$e,"f")}async finalMessage(){return await this.done(),s(this,Oe,"m",Xe).call(this)}async finalText(){return await this.done(),s(this,Oe,"m",Ge).call(this)}_emit(e,...r){if(s(this,Be,"f"))return;"end"===e&&(t(this,Be,!0,"f"),s(this,je,"f").call(this));const n=s(this,We,"f")[e];if(n&&(s(this,We,"f")[e]=n.filter(e=>!e.once),n.forEach(({listener:e})=>e(...r))),"abort"===e){const e=r[0];return s(this,He,"f")||n?.length||Promise.reject(e),s(this,Ue,"f").call(this,e),s(this,Fe,"f").call(this,e),void this._emit("end")}if("error"===e){const e=r[0];s(this,He,"f")||n?.length||Promise.reject(e),s(this,Ue,"f").call(this,e),s(this,Fe,"f").call(this,e),this._emit("end")}}_emitFinal(){this.receivedMessages.at(-1)&&this._emit("finalMessage",s(this,Oe,"m",Xe).call(this))}async _fromReadableStream(e,t){const r=t?.signal;let n;r&&(r.aborted&&this.controller.abort(),n=this.controller.abort.bind(this.controller),r.addEventListener("abort",n));try{s(this,Oe,"m",Qe).call(this),this._connected(null);const t=Z.fromReadableStream(e,this.controller);for await(const e of t)s(this,Oe,"m",Ze).call(this,e);if(t.controller.signal?.aborted)throw new c;s(this,Oe,"m",et).call(this)}finally{r&&n&&r.removeEventListener("abort",n)}}[($e=new WeakMap,Le=new WeakMap,Ne=new WeakMap,De=new WeakMap,Ue=new WeakMap,qe=new WeakMap,je=new WeakMap,Fe=new WeakMap,We=new WeakMap,Be=new WeakMap,Je=new WeakMap,ze=new WeakMap,He=new WeakMap,Ke=new WeakMap,Ve=new WeakMap,Ye=new WeakMap,Oe=new WeakSet,Xe=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");return this.receivedMessages.at(-1)},Ge=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");const e=this.receivedMessages.at(-1).content.filter(e=>"text"===e.type).map(e=>e.text);if(0===e.length)throw new o("stream ended without producing a content block with type=text");return e.join(" ")},Qe=function(){this.ended||t(this,$e,void 0,"f")},Ze=function(e){if(this.ended)return;const r=s(this,Oe,"m",tt).call(this,e);switch(this._emit("streamEvent",e,r),e.type){case"content_block_delta":{const t=r.content.at(-1);switch(e.delta.type){case"text_delta":"text"===t.type&&this._emit("text",e.delta.text,t.text||"");break;case"citations_delta":"text"===t.type&&this._emit("citation",e.delta.citation,t.citations??[]);break;case"input_json_delta":rt(t)&&t.input&&this._emit("inputJson",e.delta.partial_json,t.input);break;case"thinking_delta":"thinking"===t.type&&this._emit("thinking",e.delta.thinking,t.thinking);break;case"signature_delta":"thinking"===t.type&&this._emit("signature",t.signature);break;default:e.delta}break}case"message_stop":this._addMessageParam(r),this._addMessage(Te(r,s(this,Le,"f")),!0);break;case"content_block_stop":this._emit("contentBlock",r.content.at(-1));break;case"message_start":t(this,$e,r,"f")}},et=function(){if(this.ended)throw new o("stream has ended, this shouldn't happen");const e=s(this,$e,"f");if(!e)throw new o("request ended without sending any chunks");return t(this,$e,void 0,"f"),Te(e,s(this,Le,"f"))},tt=function(e){let t=s(this,$e,"f");if("message_start"===e.type){if(t)throw new o(`Unexpected event order, got ${e.type} before receiving "message_stop"`);return e.message}if(!t)throw new o(`Unexpected event order, got ${e.type} before "message_start"`);switch(e.type){case"message_stop":case"content_block_stop":return t;case"message_delta":return t.container=e.delta.container,t.stop_reason=e.delta.stop_reason,t.stop_sequence=e.delta.stop_sequence,t.usage.output_tokens=e.usage.output_tokens,t.context_management=e.context_management,null!=e.usage.input_tokens&&(t.usage.input_tokens=e.usage.input_tokens),null!=e.usage.cache_creation_input_tokens&&(t.usage.cache_creation_input_tokens=e.usage.cache_creation_input_tokens),null!=e.usage.cache_read_input_tokens&&(t.usage.cache_read_input_tokens=e.usage.cache_read_input_tokens),null!=e.usage.server_tool_use&&(t.usage.server_tool_use=e.usage.server_tool_use),t;case"content_block_start":return t.content.push(e.content_block),t;case"content_block_delta":{const r=t.content.at(e.index);switch(e.delta.type){case"text_delta":"text"===r?.type&&(t.content[e.index]={...r,text:(r.text||"")+e.delta.text});break;case"citations_delta":"text"===r?.type&&(t.content[e.index]={...r,citations:[...r.citations??[],e.delta.citation]});break;case"input_json_delta":if(r&&rt(r)){let n=r[st]||"";n+=e.delta.partial_json;const a={...r};if(Object.defineProperty(a,st,{value:n,enumerable:!1,writable:!0}),n)try{a.input=Ie(n)}catch(e){const t=new o(`Unable to parse tool parameter JSON from model. Please retry your request or adjust your prompt. Error: ${e}. JSON: ${n}`);s(this,Ye,"f").call(this,t)}t.content[e.index]=a}break;case"thinking_delta":"thinking"===r?.type&&(t.content[e.index]={...r,thinking:r.thinking+e.delta.thinking});break;case"signature_delta":"thinking"===r?.type&&(t.content[e.index]={...r,signature:e.delta.signature});break;default:e.delta}return t}}},Symbol.asyncIterator)](){const e=[],t=[];let s=!1;return this.on("streamEvent",s=>{const r=t.shift();r?r.resolve(s):e.push(s)}),this.on("end",()=>{s=!0;for(const e of t)e.resolve(void 0);t.length=0}),this.on("abort",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),this.on("error",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),{next:async()=>e.length?{value:e.shift(),done:!1}:s?{value:void 0,done:!0}:new Promise((e,s)=>t.push({resolve:e,reject:s})).then(e=>e?{value:e,done:!1}:{value:void 0,done:!0}),return:async()=>(this.abort(),{value:void 0,done:!0})}}toReadableStream(){return new Z(this[Symbol.asyncIterator].bind(this),this.controller).toReadableStream()}}var at,ot,it,ct,lt,dt,ht,ut,pt,ft,mt;function gt(){let e,t;return{promise:new Promise((s,r)=>{e=s,t=r}),resolve:e,reject:t}}class wt{constructor(e,s,r){at.add(this),this.client=e,ot.set(this,!1),it.set(this,!1),ct.set(this,void 0),lt.set(this,void 0),dt.set(this,void 0),ht.set(this,void 0),ut.set(this,void 0),pt.set(this,0),t(this,ct,{params:{...s,messages:structuredClone(s.messages)}},"f"),t(this,lt,{...r,headers:_e([{"x-stainless-helper":"BetaToolRunner"},r?.headers])},"f"),t(this,ut,gt(),"f")}async*[(ot=new WeakMap,it=new WeakMap,ct=new WeakMap,lt=new WeakMap,dt=new WeakMap,ht=new WeakMap,ut=new WeakMap,pt=new WeakMap,at=new WeakSet,ft=async function(){const e=s(this,ct,"f").params.compactionControl;if(!e||!e.enabled)return!1;let t=0;if(void 0!==s(this,dt,"f"))try{const e=await s(this,dt,"f");t=e.usage.input_tokens+(e.usage.cache_creation_input_tokens??0)+(e.usage.cache_read_input_tokens??0)+e.usage.output_tokens}catch{return!1}if(t<(e.contextTokenThreshold??1e5))return!1;const r=e.model??s(this,ct,"f").params.model,n=e.summaryPrompt??"You have been working on the task described above but have not yet completed it. Write a continuation summary that will allow you (or another instance of yourself) to resume work efficiently in a future context window where the conversation history will be replaced with this summary. Your summary should be structured, concise, and actionable. Include:\n1. Task Overview\nThe user's core request and success criteria\nAny clarifications or constraints they specified\n2. Current State\nWhat has been completed so far\nFiles created, modified, or analyzed (with paths if relevant)\nKey outputs or artifacts produced\n3. Important Discoveries\nTechnical constraints or requirements uncovered\nDecisions made and their rationale\nErrors encountered and how they were resolved\nWhat approaches were tried that didn't work (and why)\n4. Next Steps\nSpecific actions needed to complete the task\nAny blockers or open questions to resolve\nPriority order if multiple steps remain\n5. Context to Preserve\nUser preferences or style requirements\nDomain-specific details that aren't obvious\nAny promises made to the user\nBe concise but complete—err on the side of including information that would prevent duplicate work or repeated mistakes. Write in a way that enables immediate resumption of the task.\nWrap your summary in <summary></summary> tags.",a=s(this,ct,"f").params.messages;if("assistant"===a[a.length-1].role){const e=a[a.length-1];if(Array.isArray(e.content)){const t=e.content.filter(e=>"tool_use"!==e.type);0===t.length?a.pop():e.content=t}}const i=await this.client.beta.messages.create({model:r,messages:[...a,{role:"user",content:[{type:"text",text:n}]}],max_tokens:s(this,ct,"f").params.max_tokens},{headers:{"x-stainless-helper":"compaction"}});if("text"!==i.content[0]?.type)throw new o("Expected text response for compaction");return s(this,ct,"f").params.messages=[{role:"user",content:i.content}],!0},Symbol.asyncIterator)](){var e;if(s(this,ot,"f"))throw new o("Cannot iterate over a consumed stream");t(this,ot,!0,"f"),t(this,it,!0,"f"),t(this,ht,void 0,"f");try{for(;;){let r;try{if(s(this,ct,"f").params.max_iterations&&s(this,pt,"f")>=s(this,ct,"f").params.max_iterations)break;t(this,it,!1,"f"),t(this,ht,void 0,"f"),t(this,pt,(e=s(this,pt,"f"),++e),"f"),t(this,dt,void 0,"f");const{max_iterations:n,compactionControl:a,...o}=s(this,ct,"f").params;if(o.stream?(r=this.client.beta.messages.stream({...o},s(this,lt,"f")),t(this,dt,r.finalMessage(),"f"),s(this,dt,"f").catch(()=>{}),yield r):(t(this,dt,this.client.beta.messages.create({...o,stream:!1},s(this,lt,"f")),"f"),yield s(this,dt,"f")),!await s(this,at,"m",ft).call(this)){if(!s(this,it,"f")){const{role:e,content:t}=await s(this,dt,"f");s(this,ct,"f").params.messages.push({role:e,content:t})}const e=await s(this,at,"m",mt).call(this,s(this,ct,"f").params.messages.at(-1));if(e)s(this,ct,"f").params.messages.push(e);else if(!s(this,it,"f"))break}}finally{r&&r.abort()}}if(!s(this,dt,"f"))throw new o("ToolRunner concluded without a message from the server");s(this,ut,"f").resolve(await s(this,dt,"f"))}catch(e){throw t(this,ot,!1,"f"),s(this,ut,"f").promise.catch(()=>{}),s(this,ut,"f").reject(e),t(this,ut,gt(),"f"),e}}setMessagesParams(e){s(this,ct,"f").params="function"==typeof e?e(s(this,ct,"f").params):e,t(this,it,!0,"f"),t(this,ht,void 0,"f")}async generateToolResponse(){const e=await s(this,dt,"f")??this.params.messages.at(-1);return e?s(this,at,"m",mt).call(this,e):null}done(){return s(this,ut,"f").promise}async runUntilDone(){if(!s(this,ot,"f"))for await(const e of this);return this.done()}get params(){return s(this,ct,"f").params}pushMessages(...e){this.setMessagesParams(t=>({...t,messages:[...t.messages,...e]}))}then(e,t){return this.runUntilDone().then(e,t)}}mt=async function(e){return void 0!==s(this,ht,"f")||t(this,ht,async function(e,t=e.messages.at(-1)){if(!t||"assistant"!==t.role||!t.content||"string"==typeof t.content)return null;const s=t.content.filter(e=>"tool_use"===e.type);return 0===s.length?null:{role:"user",content:await Promise.all(s.map(async t=>{const s=e.tools.find(e=>("name"in e?e.name:e.mcp_server_name)===t.name);if(!s||!("run"in s))return{type:"tool_result",tool_use_id:t.id,content:`Error: Tool '${t.name}' not found`,is_error:!0};try{let e=t.input;"parse"in s&&s.parse&&(e=s.parse(e));const r=await s.run(e);return{type:"tool_result",tool_use_id:t.id,content:r}}catch(e){return{type:"tool_result",tool_use_id:t.id,content:`Error: ${e instanceof Error?e.message:String(e)}`,is_error:!0}}}))}}(s(this,ct,"f").params,e),"f"),s(this,ht,"f")};class yt{constructor(e,t){this.iterator=e,this.controller=t}async*decoder(){const e=new q;for await(const t of this.iterator)for(const s of e.decode(t))yield JSON.parse(s);for(const t of e.flush())yield JSON.parse(t)}[Symbol.asyncIterator](){return this.decoder()}static fromResponse(e,t){if(!e.body){if(t.abort(),void 0!==globalThis.navigator&&"ReactNative"===globalThis.navigator.product)throw new o("The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api");throw new o("Attempted to iterate over a response with no body")}return new yt(C(e.body),t)}}class bt extends ye{create(e,t){const{betas:s,...r}=e;return this._client.post("/v1/messages/batches?beta=true",{body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"message-batches-2024-09-24"].toString()},t?.headers])})}retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/messages/batches/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"message-batches-2024-09-24"].toString()},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/messages/batches?beta=true",oe,{query:r,...t,headers:_e([{"anthropic-beta":[...s??[],"message-batches-2024-09-24"].toString()},t?.headers])})}delete(e,t={},s){const{betas:r}=t??{};return this._client.delete(Pe`/v1/messages/batches/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"message-batches-2024-09-24"].toString()},s?.headers])})}cancel(e,t={},s){const{betas:r}=t??{};return this._client.post(Pe`/v1/messages/batches/${e}/cancel?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"message-batches-2024-09-24"].toString()},s?.headers])})}async results(e,t={},s){const r=await this.retrieve(e);if(!r.results_url)throw new o(`No batch \`results_url\`; Has it finished processing? ${r.processing_status} - ${r.id}`);const{betas:n}=t??{};return this._client.get(r.results_url,{...s,headers:_e([{"anthropic-beta":[...n??[],"message-batches-2024-09-24"].toString(),Accept:"application/binary"},s?.headers]),stream:!0,__binaryResponse:!0})._thenUnwrap((e,t)=>yt.fromResponse(t.response,t.controller))}}const vt={"claude-1.3":"November 6th, 2024","claude-1.3-100k":"November 6th, 2024","claude-instant-1.1":"November 6th, 2024","claude-instant-1.1-100k":"November 6th, 2024","claude-instant-1.2":"November 6th, 2024","claude-3-sonnet-20240229":"July 21st, 2025","claude-3-opus-20240229":"January 5th, 2026","claude-2.1":"July 21st, 2025","claude-2.0":"July 21st, 2025","claude-3-7-sonnet-latest":"February 19th, 2026","claude-3-7-sonnet-20250219":"February 19th, 2026"};class _t extends ye{constructor(){super(...arguments),this.batches=new bt(this._client)}create(e,t){const{betas:s,...r}=e;r.model in vt&&console.warn(`The model '${r.model}' is deprecated and will reach end-of-life on ${vt[r.model]}\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`);let n=this._client._options.timeout;if(!r.stream&&null==n){const e=xe[r.model]??void 0;n=this._client.calculateNonstreamingTimeout(r.max_tokens,e)}return this._client.post("/v1/messages?beta=true",{body:r,timeout:n??6e5,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers]),stream:e.stream??!1})}parse(e,t){return t={...t,headers:_e([{"anthropic-beta":[...e.betas??[],"structured-outputs-2025-11-13"].toString()},t?.headers])},this.create(e,t).then(t=>Ae(t,e))}stream(e,t){return nt.createMessage(this,e,t)}countTokens(e,t){const{betas:s,...r}=e;return this._client.post("/v1/messages/count_tokens?beta=true",{body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"token-counting-2024-11-01"].toString()},t?.headers])})}toolRunner(e,t){return new wt(this._client,e,t)}}_t.Batches=bt,_t.BetaToolRunner=wt;class kt extends ye{create(e,t={},s){const{betas:r,...n}=t??{};return this._client.post(Pe`/v1/skills/${e}/versions?beta=true`,ue({body:n,...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])},this._client))}retrieve(e,t,s){const{skill_id:r,betas:n}=t;return this._client.get(Pe`/v1/skills/${r}/versions/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...n??[],"skills-2025-10-02"].toString()},s?.headers])})}list(e,t={},s){const{betas:r,...n}=t??{};return this._client.getAPIList(Pe`/v1/skills/${e}/versions?beta=true`,ie,{query:n,...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])})}delete(e,t,s){const{skill_id:r,betas:n}=t;return this._client.delete(Pe`/v1/skills/${r}/versions/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...n??[],"skills-2025-10-02"].toString()},s?.headers])})}}class St extends ye{constructor(){super(...arguments),this.versions=new kt(this._client)}create(e={},t){const{betas:s,...r}=e??{};return this._client.post("/v1/skills?beta=true",ue({body:r,...t,headers:_e([{"anthropic-beta":[...s??[],"skills-2025-10-02"].toString()},t?.headers])},this._client))}retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/skills/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/skills?beta=true",ie,{query:r,...t,headers:_e([{"anthropic-beta":[...s??[],"skills-2025-10-02"].toString()},t?.headers])})}delete(e,t={},s){const{betas:r}=t??{};return this._client.delete(Pe`/v1/skills/${e}?beta=true`,{...s,headers:_e([{"anthropic-beta":[...r??[],"skills-2025-10-02"].toString()},s?.headers])})}}St.Versions=kt;class Mt extends ye{constructor(){super(...arguments),this.models=new Re(this._client),this.messages=new _t(this._client),this.files=new Ee(this._client),this.skills=new St(this._client)}}Mt.Models=Re,Mt.Messages=_t,Mt.Files=Ee,Mt.Skills=St;class Pt extends ye{create(e,t){const{betas:s,...r}=e;return this._client.post("/v1/complete",{body:r,timeout:this._client._options.timeout??6e5,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers]),stream:e.stream??!1})}}var Et,Rt,xt,Tt,At,Ct,It,Ot,$t,Lt,Nt,Dt,Ut,qt,jt,Ft,Wt,Bt,Jt,zt,Ht,Kt;const Vt="__json_buf";function Xt(e){return"tool_use"===e.type||"server_tool_use"===e.type}class Gt{constructor(){Et.add(this),this.messages=[],this.receivedMessages=[],Rt.set(this,void 0),this.controller=new AbortController,xt.set(this,void 0),Tt.set(this,()=>{}),At.set(this,()=>{}),Ct.set(this,void 0),It.set(this,()=>{}),Ot.set(this,()=>{}),$t.set(this,{}),Lt.set(this,!1),Nt.set(this,!1),Dt.set(this,!1),Ut.set(this,!1),qt.set(this,void 0),jt.set(this,void 0),Bt.set(this,e=>{if(t(this,Nt,!0,"f"),n(e)&&(e=new c),e instanceof c)return t(this,Dt,!0,"f"),this._emit("abort",e);if(e instanceof o)return this._emit("error",e);if(e instanceof Error){const t=new o(e.message);return t.cause=e,this._emit("error",t)}return this._emit("error",new o(String(e)))}),t(this,xt,new Promise((e,s)=>{t(this,Tt,e,"f"),t(this,At,s,"f")}),"f"),t(this,Ct,new Promise((e,s)=>{t(this,It,e,"f"),t(this,Ot,s,"f")}),"f"),s(this,xt,"f").catch(()=>{}),s(this,Ct,"f").catch(()=>{})}get response(){return s(this,qt,"f")}get request_id(){return s(this,jt,"f")}async withResponse(){const e=await s(this,xt,"f");if(!e)throw new Error("Could not resolve a `Response` object");return{data:this,response:e,request_id:e.headers.get("request-id")}}static fromReadableStream(e){const t=new Gt;return t._run(()=>t._fromReadableStream(e)),t}static createMessage(e,t,s){const r=new Gt;for(const e of t.messages)r._addMessageParam(e);return r._run(()=>r._createMessage(e,{...t,stream:!0},{...s,headers:{...s?.headers,"X-Stainless-Helper-Method":"stream"}})),r}_run(e){e().then(()=>{this._emitFinal(),this._emit("end")},s(this,Bt,"f"))}_addMessageParam(e){this.messages.push(e)}_addMessage(e,t=!0){this.receivedMessages.push(e),t&&this._emit("message",e)}async _createMessage(e,t,r){const n=r?.signal;let a;n&&(n.aborted&&this.controller.abort(),a=this.controller.abort.bind(this.controller),n.addEventListener("abort",a));try{s(this,Et,"m",Jt).call(this);const{response:n,data:a}=await e.create({...t,stream:!0},{...r,signal:this.controller.signal}).withResponse();this._connected(n);for await(const e of a)s(this,Et,"m",zt).call(this,e);if(a.controller.signal?.aborted)throw new c;s(this,Et,"m",Ht).call(this)}finally{n&&a&&n.removeEventListener("abort",a)}}_connected(e){this.ended||(t(this,qt,e,"f"),t(this,jt,e?.headers.get("request-id"),"f"),s(this,Tt,"f").call(this,e),this._emit("connect"))}get ended(){return s(this,Lt,"f")}get errored(){return s(this,Nt,"f")}get aborted(){return s(this,Dt,"f")}abort(){this.controller.abort()}on(e,t){return(s(this,$t,"f")[e]||(s(this,$t,"f")[e]=[])).push({listener:t}),this}off(e,t){const r=s(this,$t,"f")[e];if(!r)return this;const n=r.findIndex(e=>e.listener===t);return n>=0&&r.splice(n,1),this}once(e,t){return(s(this,$t,"f")[e]||(s(this,$t,"f")[e]=[])).push({listener:t,once:!0}),this}emitted(e){return new Promise((s,r)=>{t(this,Ut,!0,"f"),"error"!==e&&this.once("error",r),this.once(e,s)})}async done(){t(this,Ut,!0,"f"),await s(this,Ct,"f")}get currentMessage(){return s(this,Rt,"f")}async finalMessage(){return await this.done(),s(this,Et,"m",Ft).call(this)}async finalText(){return await this.done(),s(this,Et,"m",Wt).call(this)}_emit(e,...r){if(s(this,Lt,"f"))return;"end"===e&&(t(this,Lt,!0,"f"),s(this,It,"f").call(this));const n=s(this,$t,"f")[e];if(n&&(s(this,$t,"f")[e]=n.filter(e=>!e.once),n.forEach(({listener:e})=>e(...r))),"abort"===e){const e=r[0];return s(this,Ut,"f")||n?.length||Promise.reject(e),s(this,At,"f").call(this,e),s(this,Ot,"f").call(this,e),void this._emit("end")}if("error"===e){const e=r[0];s(this,Ut,"f")||n?.length||Promise.reject(e),s(this,At,"f").call(this,e),s(this,Ot,"f").call(this,e),this._emit("end")}}_emitFinal(){this.receivedMessages.at(-1)&&this._emit("finalMessage",s(this,Et,"m",Ft).call(this))}async _fromReadableStream(e,t){const r=t?.signal;let n;r&&(r.aborted&&this.controller.abort(),n=this.controller.abort.bind(this.controller),r.addEventListener("abort",n));try{s(this,Et,"m",Jt).call(this),this._connected(null);const t=Z.fromReadableStream(e,this.controller);for await(const e of t)s(this,Et,"m",zt).call(this,e);if(t.controller.signal?.aborted)throw new c;s(this,Et,"m",Ht).call(this)}finally{r&&n&&r.removeEventListener("abort",n)}}[(Rt=new WeakMap,xt=new WeakMap,Tt=new WeakMap,At=new WeakMap,Ct=new WeakMap,It=new WeakMap,Ot=new WeakMap,$t=new WeakMap,Lt=new WeakMap,Nt=new WeakMap,Dt=new WeakMap,Ut=new WeakMap,qt=new WeakMap,jt=new WeakMap,Bt=new WeakMap,Et=new WeakSet,Ft=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");return this.receivedMessages.at(-1)},Wt=function(){if(0===this.receivedMessages.length)throw new o("stream ended without producing a Message with role=assistant");const e=this.receivedMessages.at(-1).content.filter(e=>"text"===e.type).map(e=>e.text);if(0===e.length)throw new o("stream ended without producing a content block with type=text");return e.join(" ")},Jt=function(){this.ended||t(this,Rt,void 0,"f")},zt=function(e){if(this.ended)return;const r=s(this,Et,"m",Kt).call(this,e);switch(this._emit("streamEvent",e,r),e.type){case"content_block_delta":{const t=r.content.at(-1);switch(e.delta.type){case"text_delta":"text"===t.type&&this._emit("text",e.delta.text,t.text||"");break;case"citations_delta":"text"===t.type&&this._emit("citation",e.delta.citation,t.citations??[]);break;case"input_json_delta":Xt(t)&&t.input&&this._emit("inputJson",e.delta.partial_json,t.input);break;case"thinking_delta":"thinking"===t.type&&this._emit("thinking",e.delta.thinking,t.thinking);break;case"signature_delta":"thinking"===t.type&&this._emit("signature",t.signature);break;default:e.delta}break}case"message_stop":this._addMessageParam(r),this._addMessage(r,!0);break;case"content_block_stop":this._emit("contentBlock",r.content.at(-1));break;case"message_start":t(this,Rt,r,"f")}},Ht=function(){if(this.ended)throw new o("stream has ended, this shouldn't happen");const e=s(this,Rt,"f");if(!e)throw new o("request ended without sending any chunks");return t(this,Rt,void 0,"f"),e},Kt=function(e){let t=s(this,Rt,"f");if("message_start"===e.type){if(t)throw new o(`Unexpected event order, got ${e.type} before receiving "message_stop"`);return e.message}if(!t)throw new o(`Unexpected event order, got ${e.type} before "message_start"`);switch(e.type){case"message_stop":case"content_block_stop":return t;case"message_delta":return t.stop_reason=e.delta.stop_reason,t.stop_sequence=e.delta.stop_sequence,t.usage.output_tokens=e.usage.output_tokens,null!=e.usage.input_tokens&&(t.usage.input_tokens=e.usage.input_tokens),null!=e.usage.cache_creation_input_tokens&&(t.usage.cache_creation_input_tokens=e.usage.cache_creation_input_tokens),null!=e.usage.cache_read_input_tokens&&(t.usage.cache_read_input_tokens=e.usage.cache_read_input_tokens),null!=e.usage.server_tool_use&&(t.usage.server_tool_use=e.usage.server_tool_use),t;case"content_block_start":return t.content.push({...e.content_block}),t;case"content_block_delta":{const s=t.content.at(e.index);switch(e.delta.type){case"text_delta":"text"===s?.type&&(t.content[e.index]={...s,text:(s.text||"")+e.delta.text});break;case"citations_delta":"text"===s?.type&&(t.content[e.index]={...s,citations:[...s.citations??[],e.delta.citation]});break;case"input_json_delta":if(s&&Xt(s)){let r=s[Vt]||"";r+=e.delta.partial_json;const n={...s};Object.defineProperty(n,Vt,{value:r,enumerable:!1,writable:!0}),r&&(n.input=Ie(r)),t.content[e.index]=n}break;case"thinking_delta":"thinking"===s?.type&&(t.content[e.index]={...s,thinking:s.thinking+e.delta.thinking});break;case"signature_delta":"thinking"===s?.type&&(t.content[e.index]={...s,signature:e.delta.signature});break;default:e.delta}return t}}},Symbol.asyncIterator)](){const e=[],t=[];let s=!1;return this.on("streamEvent",s=>{const r=t.shift();r?r.resolve(s):e.push(s)}),this.on("end",()=>{s=!0;for(const e of t)e.resolve(void 0);t.length=0}),this.on("abort",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),this.on("error",e=>{s=!0;for(const s of t)s.reject(e);t.length=0}),{next:async()=>e.length?{value:e.shift(),done:!1}:s?{value:void 0,done:!0}:new Promise((e,s)=>t.push({resolve:e,reject:s})).then(e=>e?{value:e,done:!1}:{value:void 0,done:!0}),return:async()=>(this.abort(),{value:void 0,done:!0})}}toReadableStream(){return new Z(this[Symbol.asyncIterator].bind(this),this.controller).toReadableStream()}}class Yt extends ye{create(e,t){return this._client.post("/v1/messages/batches",{body:e,...t})}retrieve(e,t){return this._client.get(Pe`/v1/messages/batches/${e}`,t)}list(e={},t){return this._client.getAPIList("/v1/messages/batches",oe,{query:e,...t})}delete(e,t){return this._client.delete(Pe`/v1/messages/batches/${e}`,t)}cancel(e,t){return this._client.post(Pe`/v1/messages/batches/${e}/cancel`,t)}async results(e,t){const s=await this.retrieve(e);if(!s.results_url)throw new o(`No batch \`results_url\`; Has it finished processing? ${s.processing_status} - ${s.id}`);return this._client.get(s.results_url,{...t,headers:_e([{Accept:"application/binary"},t?.headers]),stream:!0,__binaryResponse:!0})._thenUnwrap((e,t)=>yt.fromResponse(t.response,t.controller))}}class Qt extends ye{constructor(){super(...arguments),this.batches=new Yt(this._client)}create(e,t){e.model in Zt&&console.warn(`The model '${e.model}' is deprecated and will reach end-of-life on ${Zt[e.model]}\nPlease migrate to a newer model. Visit https://docs.anthropic.com/en/docs/resources/model-deprecations for more information.`);let s=this._client._options.timeout;if(!e.stream&&null==s){const t=xe[e.model]??void 0;s=this._client.calculateNonstreamingTimeout(e.max_tokens,t)}return this._client.post("/v1/messages",{body:e,timeout:s??6e5,...t,stream:e.stream??!1})}stream(e,t){return Gt.createMessage(this,e,t)}countTokens(e,t){return this._client.post("/v1/messages/count_tokens",{body:e,...t})}}const Zt={"claude-1.3":"November 6th, 2024","claude-1.3-100k":"November 6th, 2024","claude-instant-1.1":"November 6th, 2024","claude-instant-1.1-100k":"November 6th, 2024","claude-instant-1.2":"November 6th, 2024","claude-3-sonnet-20240229":"July 21st, 2025","claude-3-opus-20240229":"January 5th, 2026","claude-2.1":"July 21st, 2025","claude-2.0":"July 21st, 2025","claude-3-7-sonnet-latest":"February 19th, 2026","claude-3-7-sonnet-20250219":"February 19th, 2026"};Qt.Batches=Yt;class es extends ye{retrieve(e,t={},s){const{betas:r}=t??{};return this._client.get(Pe`/v1/models/${e}`,{...s,headers:_e([{...null!=r?.toString()?{"anthropic-beta":r?.toString()}:void 0},s?.headers])})}list(e={},t){const{betas:s,...r}=e??{};return this._client.getAPIList("/v1/models",oe,{query:r,...t,headers:_e([{...null!=s?.toString()?{"anthropic-beta":s?.toString()}:void 0},t?.headers])})}}const ts=e=>void 0!==globalThis.process?globalThis.process.env?.[e]?.trim()??void 0:void 0!==globalThis.Deno?globalThis.Deno.env?.get?.(e)?.trim():void 0;var ss,rs,ns,as,os,is;class cs{constructor({baseURL:e=ts("ANTHROPIC_BASE_URL"),apiKey:s=ts("ANTHROPIC_API_KEY")??null,authToken:r=ts("ANTHROPIC_AUTH_TOKEN")??null,...n}={}){ss.add(this),ns.set(this,void 0);const a={apiKey:s,authToken:r,...n,baseURL:e||"https://api.anthropic.com"};if(!a.dangerouslyAllowBrowser&&"undefined"!=typeof window&&void 0!==window.document&&"undefined"!=typeof navigator)throw new o("It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\nIf you understand the risks and have appropriate mitigations in place,\nyou can set the `dangerouslyAllowBrowser` option to `true`, e.g.,\n\nnew Anthropic({ apiKey, dangerouslyAllowBrowser: true });\n");this.baseURL=a.baseURL,this.timeout=a.timeout??rs.DEFAULT_TIMEOUT,this.logger=a.logger??console;const i="warn";this.logLevel=i,this.logLevel=B(a.logLevel,"ClientOptions.logLevel",this)??B(ts("ANTHROPIC_LOG"),"process.env['ANTHROPIC_LOG']",this)??i,this.fetchOptions=a.fetchOptions,this.maxRetries=a.maxRetries??2,this.fetch=a.fetch??function(){if("undefined"!=typeof fetch)return fetch;throw new Error("`fetch` is not defined as a global; Either pass `fetch` to the client, `new Anthropic({ fetch })` or polyfill the global, `globalThis.fetch = fetch`")}(),t(this,ns,I,"f"),this._options=a,this.apiKey="string"==typeof s?s:null,this.authToken=r}withOptions(e){return new this.constructor({...this._options,baseURL:this.baseURL,maxRetries:this.maxRetries,timeout:this.timeout,logger:this.logger,logLevel:this.logLevel,fetch:this.fetch,fetchOptions:this.fetchOptions,apiKey:this.apiKey,authToken:this.authToken,...e})}defaultQuery(){return this._options.defaultQuery}validateHeaders({values:e,nulls:t}){if(!e.get("x-api-key")&&!e.get("authorization")&&!(this.apiKey&&e.get("x-api-key")||t.has("x-api-key")||this.authToken&&e.get("authorization")||t.has("authorization")))throw new Error('Could not resolve authentication method. Expected either apiKey or authToken to be set. Or for one of the "X-Api-Key" or "Authorization" headers to be explicitly omitted')}async authHeaders(e){return _e([await this.apiKeyAuth(e),await this.bearerAuth(e)])}async apiKeyAuth(e){if(null!=this.apiKey)return _e([{"X-Api-Key":this.apiKey}])}async bearerAuth(e){if(null!=this.authToken)return _e([{Authorization:`Bearer ${this.authToken}`}])}stringifyQuery(e){return Object.entries(e).filter(([e,t])=>void 0!==t).map(([e,t])=>{if("string"==typeof t||"number"==typeof t||"boolean"==typeof t)return`${encodeURIComponent(e)}=${encodeURIComponent(t)}`;if(null===t)return`${encodeURIComponent(e)}=`;throw new o(`Cannot stringify type ${typeof t}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`)}).join("&")}getUserAgent(){return`${this.constructor.name}/JS ${M}`}defaultIdempotencyKey(){return`stainless-node-retry-${r()}`}makeStatusError(e,t,s,r){return i.generate(e,t,s,r)}buildURL(e,t,r){const n=!s(this,ss,"m",as).call(this)&&r||this.baseURL,a=(e=>b.test(e))(e)?new URL(e):new URL(n+(n.endsWith("/")&&e.startsWith("/")?e.slice(1):e)),o=this.defaultQuery();return function(e){if(!e)return!0;for(const t in e)return!1;return!0}(o)||(t={...o,...t}),"object"==typeof t&&t&&!Array.isArray(t)&&(a.search=this.stringifyQuery(t)),a.toString()}_calculateNonstreamingTimeout(e){if(3600*e/128e3>600)throw new o("Streaming is required for operations that may take longer than 10 minutes. See https://github.com/anthropics/anthropic-sdk-typescript#streaming-responses for more details");return 6e5}async prepareOptions(e){}async prepareRequest(e,{url:t,options:s}){}get(e,t){return this.methodRequest("get",e,t)}post(e,t){return this.methodRequest("post",e,t)}patch(e,t){return this.methodRequest("patch",e,t)}put(e,t){return this.methodRequest("put",e,t)}delete(e,t){return this.methodRequest("delete",e,t)}methodRequest(e,t,s){return this.request(Promise.resolve(s).then(s=>({method:e,path:t,...s})))}request(e,t=null){return new re(this,this.makeRequest(e,t,void 0))}async makeRequest(e,t,s){const r=await e,o=r.maxRetries??this.maxRetries;null==t&&(t=o),await this.prepareOptions(r);const{req:i,url:h,timeout:u}=await this.buildRequest(r,{retryCount:o-t});await this.prepareRequest(i,{url:h,options:r});const p="log_"+(Math.random()*(1<<24)|0).toString(16).padStart(6,"0"),f=void 0===s?"":`, retryOf: ${s}`,m=Date.now();if(V(this).debug(`[${p}] sending request`,X({retryOfRequestLogID:s,method:r.method,url:h,options:r,headers:i.headers})),r.signal?.aborted)throw new c;const g=new AbortController,w=await this.fetchWithTimeout(h,i,u,g).catch(a),y=Date.now();if(w instanceof globalThis.Error){const e=`retrying, ${t} attempts remaining`;if(r.signal?.aborted)throw new c;const a=n(w)||/timed? ?out/i.test(String(w)+("cause"in w?String(w.cause):""));if(t)return V(this).info(`[${p}] connection ${a?"timed out":"failed"} - ${e}`),V(this).debug(`[${p}] connection ${a?"timed out":"failed"} (${e})`,X({retryOfRequestLogID:s,url:h,durationMs:y-m,message:w.message})),this.retryRequest(r,t,s??p);if(V(this).info(`[${p}] connection ${a?"timed out":"failed"} - error; no more retries left`),V(this).debug(`[${p}] connection ${a?"timed out":"failed"} (error; no more retries left)`,X({retryOfRequestLogID:s,url:h,durationMs:y-m,message:w.message})),a)throw new d;throw new l({cause:w})}const b=`[${p}${f}${[...w.headers.entries()].filter(([e])=>"request-id"===e).map(([e,t])=>", "+e+": "+JSON.stringify(t)).join("")}] ${i.method} ${h} ${w.ok?"succeeded":"failed"} with status ${w.status} in ${y-m}ms`;if(!w.ok){const e=await this.shouldRetry(w);if(t&&e){const e=`retrying, ${t} attempts remaining`;return await async function(e){if(null===e||"object"!=typeof e)return;if(e[Symbol.asyncIterator])return void await(e[Symbol.asyncIterator]().return?.());const t=e.getReader(),s=t.cancel();t.releaseLock(),await s}(w.body),V(this).info(`${b} - ${e}`),V(this).debug(`[${p}] response error (${e})`,X({retryOfRequestLogID:s,url:w.url,status:w.status,headers:w.headers,durationMs:y-m})),this.retryRequest(r,t,s??p,w.headers)}const n=e?"error; no more retries left":"error; not retryable";V(this).info(`${b} - ${n}`);const o=await w.text().catch(e=>a(e).message),i=S(o),c=i?void 0:o;throw V(this).debug(`[${p}] response error (${n})`,X({retryOfRequestLogID:s,url:w.url,status:w.status,headers:w.headers,message:c,durationMs:Date.now()-m})),this.makeStatusError(w.status,i,c,w.headers)}return V(this).info(b),V(this).debug(`[${p}] response start`,X({retryOfRequestLogID:s,url:w.url,status:w.status,headers:w.headers,durationMs:y-m})),{response:w,options:r,controller:g,requestLogID:p,retryOfRequestLogID:s,startTime:m}}getAPIList(e,t,s){return this.requestAPIList(t,{method:"get",path:e,...s})}requestAPIList(e,t){const s=this.makeRequest(t,null,void 0);return new ae(this,s,e)}async fetchWithTimeout(e,t,s,r){const{signal:n,method:a,...o}=t||{};n&&n.addEventListener("abort",()=>r.abort());const i=setTimeout(()=>r.abort(),s),c=globalThis.ReadableStream&&o.body instanceof globalThis.ReadableStream||"object"==typeof o.body&&null!==o.body&&Symbol.asyncIterator in o.body,l={signal:r.signal,...c?{duplex:"half"}:{},method:"GET",...o};a&&(l.method=a.toUpperCase());try{return await this.fetch.call(void 0,e,l)}finally{clearTimeout(i)}}async shouldRetry(e){const t=e.headers.get("x-should-retry");return"true"===t||"false"!==t&&(408===e.status||409===e.status||429===e.status||e.status>=500)}async retryRequest(e,t,s,r){let n;const a=r?.get("retry-after-ms");if(a){const e=parseFloat(a);Number.isNaN(e)||(n=e)}const o=r?.get("retry-after");if(o&&!n){const e=parseFloat(o);n=Number.isNaN(e)?Date.parse(o)-Date.now():1e3*e}if(!(n&&0<=n&&n<6e4)){const s=e.maxRetries??this.maxRetries;n=this.calculateDefaultRetryTimeoutMillis(t,s)}var i;return await(i=n,new Promise(e=>setTimeout(e,i))),this.makeRequest(e,t-1,s)}calculateDefaultRetryTimeoutMillis(e,t){const s=t-e;return Math.min(.5*Math.pow(2,s),8)*(1-.25*Math.random())*1e3}calculateNonstreamingTimeout(e,t){const s=6e5;if(36e5*e/128e3>s||null!=t&&e>t)throw new o("Streaming is required for operations that may take longer than 10 minutes. See https://github.com/anthropics/anthropic-sdk-typescript#long-requests for more details");return s}async buildRequest(e,{retryCount:t=0}={}){const s={...e},{method:r,path:n,query:a,defaultBaseURL:i}=s,c=this.buildURL(n,a,i);"timeout"in s&&((e,t)=>{if("number"!=typeof t||!Number.isInteger(t))throw new o(`${e} must be an integer`);if(t<0)throw new o(`${e} must be a positive integer`)})("timeout",s.timeout),s.timeout=s.timeout??this.timeout;const{bodyHeaders:l,body:d}=this.buildBody({options:s});return{req:{method:r,headers:await this.buildHeaders({options:e,method:r,bodyHeaders:l,retryCount:t}),...s.signal&&{signal:s.signal},...globalThis.ReadableStream&&d instanceof globalThis.ReadableStream&&{duplex:"half"},...d&&{body:d},...this.fetchOptions??{},...s.fetchOptions??{}},url:c,timeout:s.timeout}}async buildHeaders({options:e,method:t,bodyHeaders:s,retryCount:r}){let n={};this.idempotencyHeader&&"get"!==t&&(e.idempotencyKey||(e.idempotencyKey=this.defaultIdempotencyKey()),n[this.idempotencyHeader]=e.idempotencyKey);const a=_e([n,{Accept:"application/json","User-Agent":this.getUserAgent(),"X-Stainless-Retry-Count":String(r),...e.timeout?{"X-Stainless-Timeout":String(Math.trunc(e.timeout/1e3))}:{},...x??(x=P()),...this._options.dangerouslyAllowBrowser?{"anthropic-dangerous-direct-browser-access":"true"}:void 0,"anthropic-version":"2023-06-01"},await this.authHeaders(e),this._options.defaultHeaders,s,e.headers]);return this.validateHeaders(a),a.values}buildBody({options:{body:e,headers:t}}){if(!e)return{bodyHeaders:void 0,body:void 0};const r=_e([t]);return ArrayBuffer.isView(e)||e instanceof ArrayBuffer||e instanceof DataView||"string"==typeof e&&r.values.has("content-type")||globalThis.Blob&&e instanceof globalThis.Blob||e instanceof FormData||e instanceof URLSearchParams||globalThis.ReadableStream&&e instanceof globalThis.ReadableStream?{bodyHeaders:void 0,body:e}:"object"==typeof e&&(Symbol.asyncIterator in e||Symbol.iterator in e&&"next"in e&&"function"==typeof e.next)?{bodyHeaders:void 0,body:A(e)}:s(this,ns,"f").call(this,{body:e,headers:r})}}rs=cs,ns=new WeakMap,ss=new WeakSet,as=function(){return"https://api.anthropic.com"!==this.baseURL},cs.Anthropic=rs,cs.HUMAN_PROMPT="\\n\\nHuman:",cs.AI_PROMPT="\\n\\nAssistant:",cs.DEFAULT_TIMEOUT=6e5,cs.AnthropicError=o,cs.APIError=i,cs.APIConnectionError=l,cs.APIConnectionTimeoutError=d,cs.APIUserAbortError=c,cs.NotFoundError=f,cs.ConflictError=m,cs.RateLimitError=w,cs.BadRequestError=h,cs.AuthenticationError=u,cs.InternalServerError=y,cs.PermissionDeniedError=p,cs.UnprocessableEntityError=g,cs.toFile=async function(e,t,s){if(ce(),e=await e,t||(t=de(e)),(e=>null!=e&&"object"==typeof e&&"string"==typeof e.name&&"number"==typeof e.lastModified&&ge(e))(e))return e instanceof File&&null==t&&null==s?e:le([await e.arrayBuffer()],t??e.name,{type:e.type,lastModified:e.lastModified,...s});if((e=>null!=e&&"object"==typeof e&&"string"==typeof e.url&&"function"==typeof e.blob)(e)){const r=await e.blob();return t||(t=new URL(e.url).pathname.split(/[\\/]/).pop()),le(await we(r),t,s)}const r=await we(e);if(!s?.type){const e=r.find(e=>"object"==typeof e&&"type"in e&&e.type);"string"==typeof e&&(s={...s,type:e})}return le(r,t,s)};class ls extends cs{constructor(){super(...arguments),this.completions=new Pt(this),this.messages=new Qt(this),this.models=new es(this),this.beta=new Mt(this)}}ls.Completions=Pt,ls.Messages=Qt,ls.Models=es,ls.Beta=Mt;class ds{validateModel(e){if(null===this.availableModels||0===this.availableModels.length)return!0;if(!this.availableModels.includes(e))throw new Error(`Model '${e}' is not available for provider '${this.name}'. Available models: ${this.availableModels.join(", ")}`);return!0}validateRequest(e){if(!e.model||0===e.model.trim().length)throw new Error("Model is required");if(!e.messages||0===e.messages.length)throw new Error("Messages array is required and must not be empty");if(void 0!==e.max_tokens&&e.max_tokens<=0)throw new Error("max_tokens must be positive");if(void 0!==e.temperature&&(e.temperature<0||e.temperature>2))throw new Error("temperature must be between 0 and 2");this.validateModel(e.model)}validateCredentialsStructure(e){if(!e||!e.apiKey)throw new Error("API key is required");if("string"!=typeof e.apiKey||0===e.apiKey.trim().length)throw new Error("API key must be a non-empty string")}}class hs extends ds{constructor(){super(...arguments),this.name="anthropic",this._availableModels=null,this.defaultModels=null}get availableModels(){return this._availableModels}async fetchAvailableModels(e){this.validateCredentialsStructure(e);try{const t=new ls({apiKey:e.apiKey,dangerouslyAllowBrowser:!0}),s=(await t.models.list()).data;return this._availableModels=s.map(e=>e.id),s}catch(e){throw console.error("Failed to fetch models from Anthropic API:",e),new Error(`Failed to fetch available models: ${e?.message||"Unknown error"}`)}}getLatestModelByFamily(e,t){const s=e.filter(e=>e.id.toLowerCase().includes(t.toLowerCase()));if(0!==s.length)return s.sort((e,t)=>{const s=new Date(e.created_at).getTime();return new Date(t.created_at).getTime()-s}),s[0].id}async validateCredentials(e){this.validateCredentialsStructure(e);try{return await this.fetchAvailableModels(e),!0}catch(e){if(401===e?.status||e?.message?.includes("authentication"))throw new Error("Invalid API key");throw new Error(`Credential validation failed: ${e?.message||"Unknown error"}`)}}async makeRequest(e,t,s){this.validateRequest(e),this.validateCredentialsStructure(t);const r=new ls({apiKey:t.apiKey,dangerouslyAllowBrowser:!0});try{return e.stream&&s?await this.handleStreamingRequest(r,e,s):await this.handleNonStreamingRequest(r,e)}catch(e){throw this.handleError(e)}}async handleNonStreamingRequest(e,t){const s=await e.messages.create({model:t.model,max_tokens:t.max_tokens??4096,temperature:t.temperature,system:t.system,messages:t.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content}))}),r=s.content.find(e=>"text"===e.type);return{content:r&&"text"in r?r.text:"",model:s.model,provider:"anthropic",usage:{input_tokens:s.usage.input_tokens,output_tokens:s.usage.output_tokens},stop_reason:s.stop_reason??void 0}}async handleStreamingRequest(e,t,s){const r=await e.messages.create({model:t.model,max_tokens:t.max_tokens??4096,temperature:t.temperature,system:t.system,messages:t.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content})),stream:!0});let n,a="",o=t.model,i=0,c=0;for await(const e of r)if("message_start"===e.type)o=e.message.model,i=e.message.usage.input_tokens;else if("content_block_delta"===e.type){if("text_delta"===e.delta.type){const t=e.delta.text;a+=t,s(t)}}else"message_delta"===e.type&&(c=e.usage.output_tokens,n=e.delta.stop_reason??void 0);return{content:a,model:o,provider:"anthropic",usage:{input_tokens:i,output_tokens:c},stop_reason:n}}handleError(e){return 401===e?.status?new Error("Invalid API key or authentication failed"):429===e?.status?new Error("Rate limit exceeded. Please try again later."):400===e?.status?new Error(`Bad request: ${e?.message||"Invalid parameters"}`):500===e?.status?new Error("Anthropic API error. Please try again."):new Error(`API request failed: ${e?.message||"Unknown error"}`)}}class us extends ds{constructor(e){super(),this.name="anthropic",this._availableModels=null,this.defaultModels=null,this.serverUrl=e.credentialServerUrl.replace(/\/$/,"")}get availableModels(){return this._availableModels}async checkAuthStatus(){return(await fetch(`${this.serverUrl}/status`,{method:"GET",credentials:"include"})).json()}getSetupUrl(){return`${this.serverUrl}/setup`}async fetchAvailableModels(e){try{const e=await fetch(`${this.serverUrl}/proxy?path=/v1/models`,{method:"GET",credentials:"include"});if(!e.ok)throw new Error(`Failed to fetch models: HTTP ${e.status}`);const t=((await e.json()).data||[]).map(e=>({id:e.id,display_name:e.display_name||e.id,created_at:e.created_at||(new Date).toISOString(),type:e.type||"model"}));return this._availableModels=t.map(e=>e.id),t}catch(e){throw console.error("[ProxiedAnthropicProvider] Failed to fetch models from API:",e.message),new Error(`Failed to fetch available models: ${e.message}`)}}getLatestModelByFamily(e,t){const s=e.filter(e=>e.id.toLowerCase().includes(t.toLowerCase()));if(0!==s.length)return s.sort((e,t)=>{const s=new Date(e.created_at).getTime();return new Date(t.created_at).getTime()-s}),s[0].id}async validateCredentials(e){return(await this.checkAuthStatus()).authenticated}async makeRequest(e,t,s){if(this.validateRequest(e),!(await this.checkAuthStatus()).authenticated)throw new Error(`Not authenticated. Please visit ${this.getSetupUrl()} to set up your API key.`);try{return e.stream&&s?await this.handleStreamingRequest(e,s):await this.handleNonStreamingRequest(e)}catch(e){throw this.handleError(e)}}async handleNonStreamingRequest(e){const t={model:e.model,max_tokens:e.max_tokens??4096,temperature:e.temperature,system:e.system,messages:e.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content}))},s=await fetch(`${this.serverUrl}/proxy?path=/v1/messages`,{method:"POST",headers:{"Content-Type":"application/json"},credentials:"include",body:JSON.stringify(t)});if(!s.ok){const e=await s.json().catch(()=>({error:"Unknown error"}));throw new Error(e.error?.message||e.error||`HTTP ${s.status}`)}const r=await s.json(),n=r.content?.find(e=>"text"===e.type);return{content:n&&"text"in n?n.text:"",model:r.model,provider:"anthropic",usage:{input_tokens:r.usage?.input_tokens||0,output_tokens:r.usage?.output_tokens||0},stop_reason:r.stop_reason??void 0}}async handleStreamingRequest(e,t){const s={model:e.model,max_tokens:e.max_tokens??4096,temperature:e.temperature,system:e.system,messages:e.messages.filter(e=>"system"!==e.role).map(e=>({role:e.role,content:e.content})),stream:!0},r=await fetch(`${this.serverUrl}/proxy?path=/v1/messages`,{method:"POST",headers:{"Content-Type":"application/json"},credentials:"include",body:JSON.stringify(s)});if(!r.ok){const e=await r.json().catch(()=>({error:"Unknown error"}));throw new Error(e.error?.message||e.error||`HTTP ${r.status}`)}const n=r.body?.getReader();if(!n)throw new Error("Streaming not supported");const a=new TextDecoder;let o,i="",c=e.model,l=0,d=0;try{for(;;){const{done:e,value:s}=await n.read();if(e)break;const r=a.decode(s,{stream:!0}).split("\n");for(const e of r)if(e.startsWith("data: ")){const s=e.slice(6);if("[DONE]"===s)continue;try{const e=JSON.parse(s);if("message_start"===e.type)c=e.message.model,l=e.message.usage?.input_tokens||0;else if("content_block_delta"===e.type){if("text_delta"===e.delta?.type){const s=e.delta.text;i+=s,t(s)}}else"message_delta"===e.type&&(d=e.usage?.output_tokens||0,o=e.delta?.stop_reason??void 0)}catch{}}}}finally{n.releaseLock()}return{content:i,model:c,provider:"anthropic",usage:{input_tokens:l,output_tokens:d},stop_reason:o}}handleError(e){const t=e?.message||"Unknown error";return t.includes("401")||t.includes("authentication")?new Error(`Not authenticated. Please visit ${this.getSetupUrl()} to set up your API key.`):t.includes("429")?new Error("Rate limit exceeded. Please try again later."):t.includes("400")?new Error(`Bad request: ${t}`):new Error(`API request failed: ${t}`)}}class ps{constructor(e,t,s){this.isInitialized=!1,this.forceLocalMode=!1,this.configManager=e,this.credentialServerUrl=t,this.allowLocalMode=s??!1}setPromptHandler(e){this.promptHandler=e}static getInstance(e,t,s){if(!ps.instance){if(!e)throw new Error("ConfigManager required for first initialization");ps.instance=new ps(e,t,s)}return ps.instance}isProxiedMode(){return!!this.credentialServerUrl&&!this.forceLocalMode}isLocalModeAllowed(){return this.allowLocalMode}isLocalModeForced(){return this.forceLocalMode}async setForceLocalMode(e){if(this.forceLocalMode!==e){if(this.forceLocalMode=e,await this.configManager.setForceLocalMode(e),this.credentials=void 0,this.weightMapper){const e=this.weightMapper.getProvider();this.provider=this.createProvider(e)}console.log("[AiDelegateCore] Switched mode",{forceLocalMode:e,isProxiedMode:this.isProxiedMode()})}}async configureLocal(t,s,r=!0){this.isInitialized||await this.initialize(),this.forceLocalMode=!0,await this.configManager.saveLocal(t,s,r),this.provider=this.createProvider(t.provider),this.weightMapper=new e(t.provider,t.models),t.credentials&&(this.credentials=t.credentials),console.log("[AiDelegateCore] Configured local mode",{provider:t.provider,hasPassword:!!s})}getCredentialServerSetupUrl(){return this.credentialServerUrl?`${this.credentialServerUrl}/setup`:null}async fetchAvailableModels(){if(await this.ensureInitialized(),!this.provider)throw new Error("Provider not configured");const e=this.credentials||{apiKey:"proxied"};console.log("[AiDelegateCore] Fetching available models from provider");const t=await this.provider.fetchAvailableModels(e);return console.log("[AiDelegateCore] Fetched models:",t.map(e=>e.id)),t}async ensureInitialized(){this.isInitialized||await this.initialize()}async initialize(){if(this.isInitialized)return void console.log("[AiDelegateCore] Already initialized, skipping");this.forceLocalMode=await this.configManager.getForceLocalMode(),console.log("[AiDelegateCore] Initializing...",{isProxiedMode:this.isProxiedMode(),credentialServerUrl:this.credentialServerUrl,forceLocalMode:this.forceLocalMode,allowLocalMode:this.allowLocalMode});const t=await this.configManager.loadMetadata();if(console.log("[AiDelegateCore] Loaded metadata:",t),t){console.log("[AiDelegateCore] Using existing metadata"),this.provider=this.createProvider(t.provider),this.weightMapper=new e(t.provider,t.models);const s=await this.configManager.getPlaintextCredentials();s?(console.log("[AiDelegateCore] Using plaintext credentials (local dev mode)"),this.credentials=s):this.isProxiedMode()&&(this.credentials={apiKey:"proxied"})}else this.isProxiedMode()?(console.log("[AiDelegateCore] No metadata, initializing proxied defaults"),await this.initializeProxiedDefaults()):console.log("[AiDelegateCore] No metadata and not proxied mode - uninitialized");console.log("[AiDelegateCore] Initialization complete",{provider:!!this.provider,weightMapper:!!this.weightMapper,credentials:!!this.credentials}),this.isInitialized=!0}async initializeProxiedDefaults(){this.provider=this.createProvider("anthropic"),this.weightMapper=new e("anthropic",{}),this.credentials={apiKey:"proxied"},await this.configManager.saveMetadata("anthropic",{},!0)}async configure(e,t,s=!1){await this.applyConfig(e),await this.configManager.save(e,t,s)}async applyConfig(t){if(this.provider=this.createProvider(t.provider),this.weightMapper=new e(t.provider,t.models),t.credentials){this.credentials=t.credentials;try{await this.provider.validateCredentials(t.credentials)}catch(e){throw new Error(`Credential validation failed: ${e.message}`)}}}async makeRequest(e){this.isInitialized||await this.initialize();const t=await this.getState();if("uninitialized"===t?await this.promptForConfigurationIfNeeded():"locked"===t&&await this.promptForUnlock(),!this.provider||!this.weightMapper)throw new Error("AiDelegate is not configured. Please call configure() with provider and credentials.");if(!this.credentials)throw new Error("No credentials available. Please provide password to unlock.");let s=this.weightMapper.getModel(e.weight);console.log(`[AiDelegateCore] makeRequest weight=${e.weight}, mapped model=${s}`),s||(console.log(`[AiDelegateCore] No model for weight ${e.weight}, auto-selecting...`),s=await this.ensureModelForWeight(e.weight),console.log(`[AiDelegateCore] Auto-selected model: ${s}`));const r={model:s,messages:e.messages,max_tokens:e.max_tokens,temperature:e.temperature,stream:e.stream,system:e.system};if(e.stream&&!e.onStream)throw new Error("onStream callback is required when stream=true");try{return await this.provider.makeRequest(r,this.credentials,e.onStream)}catch(e){throw new Error(`AI request failed: ${e.message}`)}}async ensureModelForWeight(e){if(!this.provider||!this.credentials)throw new Error("Provider and credentials must be configured first");const t=await this.provider.fetchAvailableModels(this.credentials);if(0===t.length)throw new Error("No models available from provider");let s;if(await this.configManager.getUseDefaultModels())s=await this.autoSelectModelForWeight(e,t);else{if(!this.promptHandler)throw new Error("Model selection required but prompt handler not set");s=await this.promptHandler.promptForModelSelection(e,t)}return await this.configManager.setModelForWeight(e,s),this.weightMapper&&this.weightMapper.setModel(e,s),s}async autoSelectModelForWeight(e,t){if(!this.provider)throw new Error("Provider not configured");const s={light:"haiku",moderate:"sonnet",heavy:"opus"}[e];if(this.provider instanceof hs){const e=this.provider.getLatestModelByFamily(t,s);if(e)return e}const r=t.filter(e=>e.id.toLowerCase().includes(s.toLowerCase())||e.display_name.toLowerCase().includes(s.toLowerCase()));if(0===r.length)throw new Error(`No ${s} models found for ${e} weight`);return r.sort((e,t)=>{const s=new Date(e.created_at).getTime();return new Date(t.created_at).getTime()-s}),r[0].id}async getStatus(){this.isInitialized||await this.initialize();const e=await this.getState();let t=await this.configManager.hasCredentials();if(this.isProxiedMode()){const e=this.provider;if(e&&"function"==typeof e.checkAuthStatus)try{t=(await e.checkAuthStatus()).authenticated}catch{}}return{state:e,configured:!!this.provider&&!!this.weightMapper,hasCredentials:t,provider:this.provider?.name,models:this.weightMapper?.getMapping(),cacheEnabled:!1,trackingEnabled:!1}}async lock(){this.credentials=void 0,await this.configManager.clearCredentials()}async reset(){this.provider=void 0,this.weightMapper=void 0,this.credentials=void 0,this.isInitialized=!1,await this.configManager.clear()}createProvider(e){switch(e){case"anthropic":return this.isProxiedMode()?new us({credentialServerUrl:this.credentialServerUrl}):new hs;case"openai":throw new Error("OpenAI provider not yet implemented");default:throw new Error(`Unknown provider: ${e}`)}}async updateCredentials(e,t){if(!this.provider)throw new Error("Provider not configured. Call configure() first.");await this.provider.validateCredentials(e),this.credentials=e,await this.configManager.updateCredentials(e,t)}async isReady(){if(this.isInitialized||await this.initialize(),this.isProxiedMode()){const e=this.provider;if(e&&"function"==typeof e.checkAuthStatus)try{const t=await e.checkAuthStatus();return!!this.provider&&!!this.weightMapper&&t.authenticated}catch{return!1}}return!!this.provider&&!!this.weightMapper&&!!this.credentials}async getState(){if(this.isProxiedMode()){const e=this.provider;if(e&&"function"==typeof e.checkAuthStatus)try{if((await e.checkAuthStatus()).authenticated)return"unlocked"}catch{}return"uninitialized"}return await this.configManager.hasConfig()?this.credentials?"unlocked":"locked":"uninitialized"}async promptForConfigurationIfNeeded(){if(!this.promptHandler)throw new Error("Configuration required. Prompt handler not set. This should only be called from worker context with a prompt handler.");try{const e=await this.promptHandler.promptForConfiguration();await this.configure(e.config,e.password,e.useDefaultModels)}catch(e){throw new Error(`Configuration required: ${e.message}`)}}async promptForUnlock(){if(!this.promptHandler)throw new Error("Password required to unlock. Prompt handler not set. This should only be called from worker context with a prompt handler.");try{const e=await this.promptHandler.promptForUnlock();await this.unlock(e)}catch(e){throw new Error(`Unlock required: ${e.message}`)}}async unlock(e){const t=await this.configManager.unlock(e);await this.applyConfig(t)}}!function(e){e.INIT="init",e.CONFIGURE="configure",e.MAKE_REQUEST="makeRequest",e.GET_STATUS="getStatus",e.LOCK="lock",e.RESET="reset",e.UPDATE_CREDENTIALS="updateCredentials",e.IS_READY="isReady",e.UNLOCK="unlock",e.GET_SETUP_URL="getSetupUrl",e.SET_LOCAL_MODE="setLocalMode",e.IS_LOCAL_MODE_ALLOWED="isLocalModeAllowed",e.IS_LOCAL_MODE_FORCED="isLocalModeForced",e.CONFIGURE_LOCAL="configureLocal",e.FETCH_MODELS="fetchModels",e.REGISTER_PROMPT="registerPrompt",e.REGISTER_PROMPTS="registerPrompts",e.GET_PROMPT="getPrompt",e.LIST_PROMPTS="listPrompts",e.UPDATE_PROMPT="updatePrompt",e.DELETE_PROMPT="deletePrompt",e.RESET_PROMPT="resetPrompt",e.RESOLVE_CONFLICT="resolveConflict",e.RENDER_PROMPT="renderPrompt"}(os||(os={})),function(e){e.CONFIGURE="configure",e.UNLOCK="unlock",e.MODEL_SELECT="modelSelect",e.PROMPT_CONFLICT="promptConflict"}(is||(is={}));class fs{static validateMessage(e){return!(!e||"object"!=typeof e||"string"!=typeof e.id||0===e.id.length||!Object.values(os).includes(e.command))}static createSuccessResponse(e,t){return{id:e,success:!0,data:t}}static createErrorResponse(e,t){const s="string"==typeof t?t:t.message;return{id:e,success:!1,error:{message:this.sanitizeErrorMessage(s)}}}static sanitizeErrorMessage(e){return e.replace(/sk-ant-[a-zA-Z0-9_-]+/g,"[API_KEY_REDACTED]").replace(/sk-[a-zA-Z0-9_-]{48,}/g,"[API_KEY_REDACTED]").replace(/(api[_-]?key|token|password|secret)[:\s=]+[^\s]+/gi,"$1: [REDACTED]")}static generateId(){return`${Date.now()}-${Math.random().toString(36).substring(2,11)}`}}const ms="AES-GCM";async function gs(e,t){const s=new TextEncoder,r=await crypto.subtle.importKey("raw",s.encode(e),"PBKDF2",!1,["deriveKey"]);return crypto.subtle.deriveKey({name:"PBKDF2",salt:t,iterations:1e5,hash:"SHA-256"},r,{name:ms,length:256},!1,["encrypt","decrypt"])}const ws="0.1.0",ys="ai-delegate-config",bs=3e5,vs="prompts";class _s{constructor(){this.db=null}async initDB(){return this.db?this.db:new Promise((e,t)=>{const s=indexedDB.open("ai-delegate-prompts",1);s.onerror=()=>{t(new Error(`Failed to open IndexedDB: ${s.error}`))},s.onsuccess=()=>{this.db=s.result,e(this.db)},s.onupgradeneeded=e=>{const t=e.target.result;if(!t.objectStoreNames.contains(vs)){const e=t.createObjectStore(vs,{keyPath:"name"});e.createIndex("version","version",{unique:!1}),e.createIndex("locallyModified","locallyModified",{unique:!1})}}})}async get(e){try{const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([vs],"readonly").objectStore(vs).get(e);n.onsuccess=()=>{s(n.result??null)},n.onerror=()=>{r(new Error(`Failed to get prompt: ${n.error}`))}})}catch(e){return console.error("[PromptStore] get error:",e),null}}async put(e){const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([vs],"readwrite").objectStore(vs).put(e);n.onsuccess=()=>{s()},n.onerror=()=>{r(new Error(`Failed to save prompt: ${n.error}`))}})}async delete(e){const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([vs],"readwrite").objectStore(vs).delete(e);n.onsuccess=()=>{s()},n.onerror=()=>{r(new Error(`Failed to delete prompt: ${n.error}`))}})}async list(){const e=await this.initDB();return new Promise((t,s)=>{const r=e.transaction([vs],"readonly").objectStore(vs).getAll();r.onsuccess=()=>{t(r.result??[])},r.onerror=()=>{s(new Error(`Failed to list prompts: ${r.error}`))}})}async exists(e){return null!==await this.get(e)}async getModified(){const e=await this.initDB();return new Promise((t,s)=>{const r=e.transaction([vs],"readonly").objectStore(vs).index("locallyModified").getAll(IDBKeyRange.only(!0));r.onsuccess=()=>{t(r.result??[])},r.onerror=()=>{s(new Error(`Failed to get modified prompts: ${r.error}`))}})}static createStoredPrompt(e,t,s){const r=(new Date).toISOString();return{...s,name:e,version:t,locallyModified:!1,createdAt:r,updatedAt:r}}async clear(){const e=await this.initDB();return new Promise((t,s)=>{const r=e.transaction([vs],"readwrite").objectStore(vs).clear();r.onsuccess=()=>{t()},r.onerror=()=>{s(new Error(`Failed to clear prompts: ${r.error}`))}})}}class ks extends Error{constructor(e,t){super(`Undefined parameter: ${e}${t?` in prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="UndefinedParamError"}}class Ss extends Error{constructor(e,t){super(`Unreferenced parameter: ${e}${t?` in prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="UnreferencedParamError"}}class Ms extends Error{constructor(e,t){super(`Missing required parameter: ${e}${t?` for prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="MissingParamError"}}class Ps extends Error{constructor(e,t){super(`Unknown parameter: ${e}${t?` for prompt "${t}"`:""}`),this.paramName=e,this.promptName=t,this.name="UnknownParamError"}}const Es=/\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;class Rs{extractParams(e){const t=[];let s;for(Es.lastIndex=0;null!==(s=Es.exec(e));){const e=s[1];t.includes(e)||t.push(e)}return t}validateDefinition(e,t){const s=this.extractParams(e.template),r=Object.keys(e.params??{});for(const e of s)if(!r.includes(e))throw new ks(e,t);for(const e of r)if(!s.includes(e))throw new Ss(e,t);if(e.role&&!["user","assistant","system"].includes(e.role))throw new Error(`Invalid role "${e.role}" for prompt${t?` "${t}"`:""}`)}render(e,t,s){const r=this.extractParams(e),n={};for(const e of r)if(e in s)n[e]=s[e];else{if(!(e in t)||void 0===t[e].default)throw new Ms(e);n[e]=t[e].default}for(const e of Object.keys(s))if(!r.includes(e))throw new Ps(e);return e.replace(Es,(e,t)=>n[t])}renderWithSingleParam(e,t,s){let r={};if(void 0===s)r={};else if("string"==typeof s){const n=this.extractParams(e),a=n.filter(e=>!(e in t)||void 0===t[e].default),o=n.filter(e=>e in t&&void 0!==t[e].default);if(1===a.length)r[a[0]]=s;else{if(a.length>1)throw new Error(`Ambiguous single parameter: multiple required params (${a.join(", ")})`);if(1!==o.length)throw o.length>1?new Error(`Ambiguous single parameter: multiple optional params (${o.join(", ")})`):new Error("Prompt takes no parameters");r[o[0]]=s}}else r=s;return this.render(e,t,r)}}console.log("[AI Delegate Worker] Version: 0.3.4");const xs=new class{constructor(){this.dbName="ai-delegate-storage",this.storeName="config",this.db=null}async initDB(){return this.db?this.db:new Promise((e,t)=>{const s=indexedDB.open(this.dbName,1);s.onerror=()=>{t(new Error(`Failed to open IndexedDB: ${s.error}`))},s.onsuccess=()=>{this.db=s.result,e(this.db)},s.onupgradeneeded=e=>{const t=e.target.result;t.objectStoreNames.contains(this.storeName)||t.createObjectStore(this.storeName)}})}async getItem(e){try{const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([this.storeName],"readonly").objectStore(this.storeName).get(e);n.onsuccess=()=>{s(n.result??null)},n.onerror=()=>{r(new Error(`Failed to get item: ${n.error}`))}})}catch(e){return console.error("[IndexedDBAdapter] getItem error:",e),null}}async setItem(e,t){const s=await this.initDB();return new Promise((r,n)=>{const a=s.transaction([this.storeName],"readwrite").objectStore(this.storeName).put(t,e);a.onsuccess=()=>{r()},a.onerror=()=>{n(new Error(`Failed to set item: ${a.error}`))}})}async removeItem(e){const t=await this.initDB();return new Promise((s,r)=>{const n=t.transaction([this.storeName],"readwrite").objectStore(this.storeName).delete(e);n.onsuccess=()=>{s()},n.onerror=()=>{r(new Error(`Failed to remove item: ${n.error}`))}})}async hasItem(e){try{return null!==await this.getItem(e)}catch(e){return!1}}},Ts=new class{constructor(e){if("undefined"==typeof crypto||void 0===crypto.subtle||"function"!=typeof crypto.getRandomValues)throw new Error("Web Crypto API not available. This library requires a modern browser with crypto support.");this.storage=e}async save(e,t,s=!1){if(!t||0===t.trim().length)throw new Error("Password is required to save configuration");const r={provider:e.provider,models:e.models,useDefaultModels:s,enableCache:e.enableCache??!1,cacheTTL:e.cacheTTL??bs,trackUsage:e.trackUsage??!1,version:ws};e.credentials&&(r.encryptedCredentials=await this.encryptCredentials(e.credentials,t));try{await this.storage.setItem(ys,JSON.stringify(r))}catch(e){throw new Error(`Failed to save configuration: ${e?.message||"Unknown error"}`)}}async loadMetadata(){try{const e=await this.storage.getItem(ys);if(!e)return null;const t=JSON.parse(e);return t.version!==ws&&console.warn(`Configuration version mismatch. Expected ${ws}, got ${t.version}`),{provider:t.provider,models:t.models,enableCache:t.enableCache,cacheTTL:t.cacheTTL,trackUsage:t.trackUsage}}catch(e){return console.error("Failed to load configuration:",e),null}}async unlock(e){if(!e||0===e.trim().length)throw new Error("Password is required to unlock credentials");const t=await this.storage.getItem(ys);if(!t)throw new Error("No configuration found");const s=JSON.parse(t);if(!s.encryptedCredentials)throw new Error("No encrypted credentials found");const r=await this.decryptCredentials(s.encryptedCredentials,e);return{provider:s.provider,models:s.models,enableCache:s.enableCache,cacheTTL:s.cacheTTL,trackUsage:s.trackUsage,credentials:r}}async clear(){await this.storage.removeItem(ys)}async hasConfig(){return await this.storage.hasItem(ys)}async updateCredentials(e,t){const s=await this.loadMetadata();if(!s)throw new Error("No configuration found. Please configure the provider first.");const r={...s,credentials:e};await this.save(r,t)}async clearCredentials(){const e=await this.storage.getItem(ys);if(!e)return;const t=JSON.parse(e);delete t.encryptedCredentials,await this.storage.setItem(ys,JSON.stringify(t))}async hasCredentials(){try{const e=await this.storage.getItem(ys);if(!e)return!1;const t=JSON.parse(e);return!!t.encryptedCredentials||!!t.plaintextCredentials}catch{return!1}}async encryptCredentials(e,t){return async function(e,t){if(!t||0===t.trim().length)throw new Error("Passphrase is required for encryption");const s=(new TextEncoder).encode(e),r=crypto.getRandomValues(new Uint8Array(16)),n=crypto.getRandomValues(new Uint8Array(12)),a=await gs(t,r),o=await crypto.subtle.encrypt({name:ms,iv:n},a,s),i=new Uint8Array(28+o.byteLength);return i.set(r,0),i.set(n,16),i.set(new Uint8Array(o),28),btoa(String.fromCharCode(...i))}(JSON.stringify(e),t)}async decryptCredentials(e,t){const s=await async function(e,t){if(!t||0===t.trim().length)throw new Error("Passphrase is required for decryption");const s=Uint8Array.from(atob(e),e=>e.charCodeAt(0));if(s.length<28)throw new Error("Invalid encrypted data format");const r=s.slice(0,16),n=s.slice(16,28),a=s.slice(28),o=await gs(t,r);try{const e=await crypto.subtle.decrypt({name:ms,iv:n},o,a);return(new TextDecoder).decode(e)}catch(e){throw new Error("Decryption failed. Invalid passphrase or corrupted data.")}}(e,t);return JSON.parse(s)}async setModelForWeight(e,t){const s=await this.storage.getItem(ys);if(!s)throw new Error("No configuration found. Please configure the provider first.");const r=JSON.parse(s);r.models||(r.models={}),r.models[e]=t,await this.storage.setItem(ys,JSON.stringify(r))}async getModelForWeight(e){const t=await this.storage.getItem(ys);if(!t)return;const s=JSON.parse(t);return s.models?.[e]}async setUseDefaultModels(e){const t=await this.storage.getItem(ys);if(!t)throw new Error("No configuration found. Please configure the provider first.");const s=JSON.parse(t);s.useDefaultModels=e,await this.storage.setItem(ys,JSON.stringify(s))}async getUseDefaultModels(){const e=await this.storage.getItem(ys);return!!e&&(JSON.parse(e).useDefaultModels??!1)}async saveMetadata(e,t,s=!0){const r={provider:e,models:t,useDefaultModels:s,enableCache:!1,cacheTTL:bs,trackUsage:!1,version:ws};try{await this.storage.setItem(ys,JSON.stringify(r))}catch(e){throw new Error(`Failed to save configuration: ${e?.message||"Unknown error"}`)}}async saveLocal(e,t,s=!1){const r={provider:e.provider,models:e.models,useDefaultModels:s,enableCache:e.enableCache??!1,cacheTTL:e.cacheTTL??bs,trackUsage:e.trackUsage??!1,forceLocalMode:!0,version:ws};e.credentials&&(t&&t.trim().length>0?r.encryptedCredentials=await this.encryptCredentials(e.credentials,t):r.plaintextCredentials=JSON.stringify(e.credentials));try{await this.storage.setItem(ys,JSON.stringify(r))}catch(e){throw new Error(`Failed to save configuration: ${e?.message||"Unknown error"}`)}}async getPlaintextCredentials(){try{const e=await this.storage.getItem(ys);if(!e)return null;const t=JSON.parse(e);return t.plaintextCredentials?JSON.parse(t.plaintextCredentials):null}catch{return null}}async hasPlaintextCredentials(){try{const e=await this.storage.getItem(ys);return!!e&&!!JSON.parse(e).plaintextCredentials}catch{return!1}}async getForceLocalMode(){try{const e=await this.storage.getItem(ys);return!!e&&(JSON.parse(e).forceLocalMode??!1)}catch{return!1}}async setForceLocalMode(e){const t=await this.storage.getItem(ys);if(!t){const t={provider:"anthropic",useDefaultModels:!0,enableCache:!1,cacheTTL:bs,trackUsage:!1,forceLocalMode:e,version:ws};return void await this.storage.setItem(ys,JSON.stringify(t))}const s=JSON.parse(t);s.forceLocalMode=e,await this.storage.setItem(ys,JSON.stringify(s))}}(xs),As=new class{constructor(e){this.pendingConflicts=new Map,this.store=e??new _s,this.templateEngine=new Rs}async registerPrompt(e){const{name:t,version:s,prompt:r}=e;this.templateEngine.validateDefinition(r);const n=await this.store.get(t);if(!n){const e=_s.createStoredPrompt(t,s,r);return await this.store.put(e),console.log(`[PromptManager] Created prompt "${t}" v${s}`),{status:"created",prompt:e}}const a=function(e,t){const s=e.split(".").map(Number),r=t.split(".").map(Number);for(let e=0;e<Math.max(s.length,r.length);e++){const t=s[e]??0,n=r[e]??0;if(t<n)return-1;if(t>n)return 1}return 0}(s,n.version);if(0===a)return console.log(`[PromptManager] Prompt "${t}" unchanged (v${s})`),{status:"unchanged",prompt:n};if(a<0)return console.log(`[PromptManager] Prompt "${t}" not downgraded (v${n.version} > v${s})`),{status:"unchanged",prompt:n};if(!n.locallyModified){const e=n.version,a={...r,name:t,version:s,locallyModified:!1,createdAt:n.createdAt,updatedAt:(new Date).toISOString()};return await this.store.put(a),console.log(`[PromptManager] Auto-updated "${t}" v${e} -> v${s}`),{status:"updated",prompt:a,previousVersion:e}}const o={name:t,localVersion:n.version,upstreamVersion:s,localPrompt:n,upstreamPrompt:r};return this.pendingConflicts.set(t,o),console.log(`[PromptManager] Version conflict for "${t}": local v${n.version} (modified) vs upstream v${s}`),{status:"conflict",conflict:o}}async registerPrompts(e){const t=[];for(const s of e){const e=await this.registerPrompt(s);t.push(e)}return t}async getPrompt(e){return this.store.get(e)}async listPrompts(){return this.store.list()}async updatePrompt(e,t){this.templateEngine.validateDefinition(t);const s=await this.store.get(e);if(!s)throw new Error(`Prompt "${e}" not found`);const r={...t,name:e,version:s.version,locallyModified:!0,upstreamVersion:s.locallyModified?s.upstreamVersion:s.version,upstreamTemplate:s.locallyModified?s.upstreamTemplate:s.template,upstreamWeight:s.locallyModified?s.upstreamWeight:s.weight,createdAt:s.createdAt,updatedAt:(new Date).toISOString()};await this.store.put(r),console.log(`[PromptManager] User modified prompt "${e}"`)}async deletePrompt(e){await this.store.delete(e),this.pendingConflicts.delete(e),console.log(`[PromptManager] Deleted prompt "${e}"`)}async resolveConflict(e,t,s,r){const n=await this.store.get(e);if(!n)throw new Error(`Prompt "${e}" not found`);if("local"===t){const t={...n,upstreamVersion:r,upstreamTemplate:s.template,updatedAt:(new Date).toISOString()};await this.store.put(t),console.log(`[PromptManager] Conflict resolved for "${e}": kept local version`)}else{const t={...s,name:e,version:r,locallyModified:!1,upstreamVersion:void 0,upstreamTemplate:void 0,createdAt:n.createdAt,updatedAt:(new Date).toISOString()};await this.store.put(t),console.log(`[PromptManager] Conflict resolved for "${e}": accepted upstream v${r}`)}this.pendingConflicts.delete(e)}async resetToUpstream(e){const t=await this.store.get(e);if(!t)throw new Error(`Prompt "${e}" not found`);if(!t.locallyModified||!t.upstreamTemplate)throw new Error(`Prompt "${e}" has no original version to reset to`);const s={...t,template:t.upstreamTemplate,weight:t.upstreamWeight,locallyModified:!1,upstreamVersion:void 0,upstreamTemplate:void 0,upstreamWeight:void 0,updatedAt:(new Date).toISOString()};await this.store.put(s),console.log(`[PromptManager] Reset prompt "${e}" to upstream version`)}async renderPrompt(e,t){const s=await this.store.get(e);if(!s)throw new Error(`Prompt "${e}" not found`);const r=this.templateEngine.render(s.template,s.params??{},t??{});return{role:s.role??"user",content:r,expect_tags:s.expect_tags,weight:s.weight,promptName:e}}getPendingConflict(e){return this.pendingConflicts.get(e)}hasPendingConflicts(){return this.pendingConflicts.size>0}getPendingConflicts(){return Array.from(this.pendingConflicts.values())}};let Cs=null,Is=!1;function Os(e,t){Is||(Cs=ps.getInstance(Ts,e,t),Cs.setPromptHandler(Ds),Is=!0,console.log("[AI Delegate Worker] Initialized with credential server:",e||"(not configured)","allowLocalMode:",t))}function $s(){return Cs||Os(),Cs}const Ls=new Map;async function Ns(e,t){const s=fs.generateId();return new Promise((r,n)=>{Ls.set(s,{resolve:r,reject:n});const a={type:"prompt",promptType:e,requestId:s,data:t};self.postMessage(a),setTimeout(()=>{Ls.has(s)&&(Ls.delete(s),n(new Error("Prompt timeout - user did not respond")))},3e5)})}const Ds={async promptForConfiguration(){const e=await Ns(is.CONFIGURE),{password:t,useDefaultModels:s,...r}=e;return{config:r,password:t,useDefaultModels:s??!1}},promptForUnlock:async()=>await Ns(is.UNLOCK),promptForModelSelection:async(e,t)=>await Ns(is.MODEL_SELECT,{weight:e,availableModels:t}),promptForConflictResolution:async e=>await Ns(is.PROMPT_CONFLICT,e)};self.addEventListener("message",async e=>{const t=e.data;if("promptResponse"===t.type){const e=t,s=Ls.get(e.requestId);return void(s&&(Ls.delete(e.requestId),e.success?s.resolve(e.data):s.reject(new Error(e.error||"Prompt failed"))))}if(!fs.validateMessage(t)){const e=fs.createErrorResponse(t?.id||"unknown","Invalid message format");return void self.postMessage(e)}try{const e=await async function(e){const{id:t,command:s,payload:r}=e;switch(s){case os.INIT:return Os(r.credentialServerUrl,r.allowLocalMode),fs.createSuccessResponse(t);case os.CONFIGURE:return await $s().configure(r.config,r.password),fs.createSuccessResponse(t);case os.MAKE_REQUEST:r.options.stream&&(r.options.onStream=e=>{const s={type:"streamChunk",requestId:t,chunk:e};self.postMessage(s)});const e=await $s().makeRequest(r.options);if(r.options.stream){const e={type:"streamComplete",requestId:t};self.postMessage(e)}return fs.createSuccessResponse(t,e);case os.GET_STATUS:console.log("[Worker] GET_STATUS called, delegate initialized:",Is);const n=await $s().getStatus();return console.log("[Worker] GET_STATUS result:",n),fs.createSuccessResponse(t,n);case os.LOCK:return await $s().lock(),fs.createSuccessResponse(t);case os.RESET:return await $s().reset(),fs.createSuccessResponse(t);case os.UPDATE_CREDENTIALS:return await $s().updateCredentials(r.credentials,r.password),fs.createSuccessResponse(t);case os.IS_READY:const a=await $s().isReady();return fs.createSuccessResponse(t,a);case os.UNLOCK:return await $s().unlock(r.password),fs.createSuccessResponse(t);case os.GET_SETUP_URL:const o=$s().getCredentialServerSetupUrl();return fs.createSuccessResponse(t,o);case os.FETCH_MODELS:const i=await $s().fetchAvailableModels();return fs.createSuccessResponse(t,i);case os.SET_LOCAL_MODE:return await $s().setForceLocalMode(r.enabled),fs.createSuccessResponse(t);case os.IS_LOCAL_MODE_ALLOWED:const c=$s().isLocalModeAllowed();return fs.createSuccessResponse(t,c);case os.IS_LOCAL_MODE_FORCED:const l=$s().isLocalModeForced();return fs.createSuccessResponse(t,l);case os.CONFIGURE_LOCAL:console.log("[Worker] CONFIGURE_LOCAL received:",{config:r.config,hasPassword:!!r.password,useDefaultModels:r.useDefaultModels});try{return await $s().configureLocal(r.config,r.password,r.useDefaultModels??!0),console.log("[Worker] CONFIGURE_LOCAL completed successfully"),fs.createSuccessResponse(t)}catch(e){throw console.error("[Worker] CONFIGURE_LOCAL error:",e,e.message,e.stack),e}case os.REGISTER_PROMPT:{const e=await As.registerPrompt(r.registration);if("conflict"===e.status){const s=await Ds.promptForConflictResolution(e.conflict);await As.resolveConflict(e.conflict.name,s,e.conflict.upstreamPrompt,e.conflict.upstreamVersion);const r=await As.getPrompt(e.conflict.name);return"upstream"===s?fs.createSuccessResponse(t,{status:"updated",prompt:r,previousVersion:e.conflict.localVersion}):fs.createSuccessResponse(t,{status:"unchanged",prompt:r})}return fs.createSuccessResponse(t,e)}case os.REGISTER_PROMPTS:{const e=[];for(const t of r.registrations){const s=await As.registerPrompt(t);if("conflict"===s.status){const t=await Ds.promptForConflictResolution(s.conflict);await As.resolveConflict(s.conflict.name,t,s.conflict.upstreamPrompt,s.conflict.upstreamVersion);const r=await As.getPrompt(s.conflict.name);"upstream"===t?e.push({status:"updated",prompt:r,previousVersion:s.conflict.localVersion}):e.push({status:"unchanged",prompt:r})}else e.push(s)}return fs.createSuccessResponse(t,e)}case os.GET_PROMPT:{const e=await As.getPrompt(r.name);return fs.createSuccessResponse(t,e)}case os.LIST_PROMPTS:{const e=await As.listPrompts();return fs.createSuccessResponse(t,e)}case os.UPDATE_PROMPT:return await As.updatePrompt(r.name,r.prompt),fs.createSuccessResponse(t);case os.DELETE_PROMPT:return await As.deletePrompt(r.name),fs.createSuccessResponse(t);case os.RESET_PROMPT:return await As.resetToUpstream(r.name),fs.createSuccessResponse(t);case os.RESOLVE_CONFLICT:return await As.resolveConflict(r.name,r.choice,r.upstreamPrompt,r.upstreamVersion),fs.createSuccessResponse(t);case os.RENDER_PROMPT:{const e=await As.renderPrompt(r.name,r.params);return fs.createSuccessResponse(t,e)}default:throw new Error(`Unknown command: ${s}`)}}(t);self.postMessage(e)}catch(e){const s=fs.createErrorResponse(t.id,e);self.postMessage(s)}}),console.log("[AI Delegate Worker] Ready to receive commands")})();
//# sourceMappingURL=ai-delegate-worker.js.map'; - -/** - * Decode the base64-encoded worker source. - */ -function decodeWorkerSource(): string { - // Use atob for browser environment - if (typeof atob === 'function') { - return atob(EMBEDDED_WORKER_BASE64); - } - // Fallback for Node.js environment (for testing) - return Buffer.from(EMBEDDED_WORKER_BASE64, 'base64').toString('utf8'); -} - -/** - * The worker source code as a string. - * Lazily decoded on first access. - */ -let _cachedSource: string | null = null; -export function getWorkerSource(): string { - if (_cachedSource === null) { - _cachedSource = decodeWorkerSource(); - } - return _cachedSource; -} - -/** - * Creates a Blob URL for the embedded worker. - * The URL should be revoked with URL.revokeObjectURL() when no longer needed. - */ -export function createWorkerBlobUrl(): string { - const source = getWorkerSource(); - const blob = new Blob([source], { type: 'application/javascript' }); - return URL.createObjectURL(blob); -} - -/** - * Version marker to help with debugging cache issues. - * This is extracted from the worker bundle if present. - */ -export const EMBEDDED_WORKER_VERSION: string = '0.3.4'; -- GitLab From 076729ea043300aedf379fa461bfa807ca7df4c2 Mon Sep 17 00:00:00 2001 From: Lembot Date: Fri, 9 Jan 2026 17:54:12 -0500 Subject: [PATCH 3/3] fix: create embedded-worker stub before build Add a prebuild script that creates a placeholder embedded-worker.ts if it doesn't exist. This fixes CI builds that fail because TypeScript can't find the module that gets generated during the build. Co-Authored-By: Claude Opus 4.5 --- package.json | 3 ++- scripts/ensure-embedded-stub.js | 37 +++++++++++++++++++++++++++++++++ 2 files changed, 39 insertions(+), 1 deletion(-) create mode 100644 scripts/ensure-embedded-stub.js diff --git a/package.json b/package.json index c16c13c..38a7c1f 100644 --- a/package.json +++ b/package.json @@ -25,8 +25,9 @@ "dist" ], "scripts": { + "prebuild": "node scripts/ensure-embedded-stub.js", "build": "npm run build:worker && npm run embed-worker && npm run build:main && npm run build:types", - "build:dev": "npm run build:worker:dev && npm run embed-worker && npm run build:main:dev && npm run build:types", + "build:dev": "node scripts/ensure-embedded-stub.js && npm run build:worker:dev && npm run embed-worker && npm run build:main:dev && npm run build:types", "build:worker": "webpack --mode production --config webpack.worker.config.js", "build:worker:dev": "webpack --mode development --config webpack.worker.config.js", "build:main": "webpack --mode production --config webpack.main.config.js", diff --git a/scripts/ensure-embedded-stub.js b/scripts/ensure-embedded-stub.js new file mode 100644 index 0000000..223e0d3 --- /dev/null +++ b/scripts/ensure-embedded-stub.js @@ -0,0 +1,37 @@ +#!/usr/bin/env node +/** + * Creates a stub embedded-worker.ts if it doesn't exist. + * This allows the TypeScript compilation to succeed before the + * real embedded worker is generated. + */ + +const fs = require('fs'); +const path = require('path'); + +const OUTPUT_PATH = path.resolve(__dirname, '../src/worker/embedded-worker.ts'); + +if (fs.existsSync(OUTPUT_PATH)) { + console.log('[ensure-embedded-stub] embedded-worker.ts already exists, skipping.'); + process.exit(0); +} + +const stub = `/** + * PLACEHOLDER - AUTO-GENERATED + * This stub is created before the build and will be replaced + * by the real embedded worker after build:worker completes. + */ + +export const EMBEDDED_WORKER_VERSION: string = '0.0.0-stub'; + +export function createWorkerBlobUrl(): string { + throw new Error('Worker not yet embedded - this is a build-time stub'); +} + +export function getWorkerSource(): string { + throw new Error('Worker not yet embedded - this is a build-time stub'); +} +`; + +console.log('[ensure-embedded-stub] Creating placeholder embedded-worker.ts...'); +fs.writeFileSync(OUTPUT_PATH, stub, 'utf8'); +console.log('[ensure-embedded-stub] Done.'); -- GitLab