@getpaseo/server 0.10.0 → 0.10.2

package/dist/server/server/agent/providers/opencode/v2/turns.js

@@ -4,13 +4,24 @@ import { toDiagnosticErrorMessage } from "../../diagnostic-utils.js";
 import { renderPromptAttachmentAsText } from "../../../prompt-attachments.js";
 import { usageFromV2 } from "./mapping.js";
 import { commands } from "./commands.js";
+function isExecutionEvent(event) {
+    return (event.type === "session.execution.started" ||
+        event.type === "session.execution.succeeded" ||
+        event.type === "session.execution.failed" ||
+        event.type === "session.execution.interrupted");
+}
 export class SessionTurns {
     constructor(options) {
         this.options = options;
         this.turn = null;
         this.stopping = null;
         this.stopFailed = false;
-        this.executionError = null;
+        this.revision = 0;
+        this.execution = null;
+        this.sequence = 0;
+        this.refresh = null;
+        this.dirty = false;
+        this.retryTimer = null;
     }
     get id() {
         return this.turn?.id;
@@ -20,14 +31,47 @@ export class SessionTurns {
     }
     fail(error) {
         const turn = this.turn;
+        if (!turn)
+            return;
+        this.release(turn);
+        this.options.emit({
+            type: "turn_failed",
+            provider: "opencode",
+            turnId: turn.id,
+            error: toDiagnosticErrorMessage(error),
+        });
+    }
+    release(turn) {
         this.turn = null;
-        if (turn)
-            this.options.emit({
-                type: "turn_failed",
-                provider: "opencode",
-                turnId: turn.id,
-                error: error.message,
-            });
+        this.revision += 1;
+        if (this.retryTimer)
+            clearTimeout(this.retryTimer);
+        this.retryTimer = null;
+        turn.settle();
+    }
+    close() {
+        if (this.turn)
+            this.release(this.turn);
+    }
+    createTurn(submitted, accepted, output) {
+        let settle;
+        const completion = new Promise((resolve) => {
+            settle = resolve;
+        });
+        const turn = {
+            id: randomUUID(),
+            submitted,
+            completion,
+            settle,
+            accepted,
+            output,
+        };
+        this.turn = turn;
+        this.execution = null;
+        this.revision += 1;
+        this.options.emit({ type: "turn_started", provider: "opencode", turnId: turn.id });
+        this.scheduleRecovery();
+        return turn;
     }
     async startTurn(prompt, options) {
         await this.stopping;
@@ -35,42 +79,117 @@ export class SessionTurns {
             throw new Error("OpenCode session is closed");
         if (this.turn)
             throw new Error("OpenCode session already has an active turn");
-        this.executionError = null;
-        const id = randomUUID();
         const input = this.promptInput(prompt);
         let accept;
         const submitted = new Promise((resolve) => {
             accept = resolve;
         });
         const output = options?.outputSchema === undefined ? undefined : structuredOutput(options.outputSchema);
-        const completion = this.submit(id, input, accept, options, output);
-        this.turn = { id, submitted, completion, output };
-        return { turnId: id };
-    }
-    async submit(id, input, accept, options, output) {
-        // Defer until startTurn publishes ownership, including for immediately resolved test transports.
-        await Promise.resolve();
-        this.options.emit({ type: "turn_started", provider: "opencode", turnId: id });
+        const turn = this.createTurn(submitted, false, output);
+        void this.submit(turn, input, accept, options);
+        return { turnId: turn.id };
+    }
+    async submit(turn, input, accept, options) {
         try {
-            await this.dispatch(input, options, output);
-            accept();
-            await this.finish(id);
+            await this.dispatch(input, options, turn.output);
+            if (this.turn !== turn)
+                return;
+            turn.accepted = true;
+            this.revision += 1;
+            // Covers a fast execution whose terminal event preceded the admission response.
+            this.requestReconciliation();
         }
         catch (error) {
-            if (this.turn?.id === id) {
-                this.turn = null;
-                this.options.emit({
-                    type: "turn_failed",
-                    provider: "opencode",
-                    turnId: id,
-                    error: toDiagnosticErrorMessage(error),
-                });
-            }
+            if (this.turn === turn)
+                this.fail(new Error(toDiagnosticErrorMessage(error)));
         }
         finally {
             accept();
         }
     }
+    observe(event) {
+        if (!isExecutionEvent(event) || event.durable.seq <= this.sequence)
+            return;
+        this.revision += 1;
+        if (event.type === "session.execution.started")
+            this.observeActiveTurn();
+        this.execution = event;
+        this.sequence = event.durable.seq;
+        this.requestReconciliation();
+    }
+    requestReconciliation() {
+        void this.reconcile().catch((error) => this.options.reportReconciliationError(error));
+    }
+    // Recovery reads state; a quiet stream (including SSE comment heartbeats) is not a reason to reconnect.
+    scheduleRecovery() {
+        if (this.retryTimer || !this.turn || this.options.signal.aborted)
+            return;
+        this.retryTimer = setTimeout(() => {
+            this.retryTimer = null;
+            this.requestReconciliation();
+        }, 5000);
+        this.retryTimer.unref();
+    }
+    reconcile() {
+        this.dirty = true;
+        if (this.refresh)
+            return this.refresh;
+        this.refresh = Promise.resolve()
+            .then(() => this.drainReconciliation())
+            .finally(() => {
+            this.refresh = null;
+            this.scheduleRecovery();
+        });
+        return this.refresh;
+    }
+    async drainReconciliation() {
+        while (this.dirty && !this.options.signal.aborted) {
+            this.dirty = false;
+            await this.reconcileTurn();
+        }
+    }
+    async reconcileTurn() {
+        const revision = this.revision;
+        const turn = this.turn;
+        const active = await this.options.client().session.active({ signal: this.options.signal });
+        if (revision !== this.revision) {
+            this.dirty = true;
+            return;
+        }
+        if (active[this.options.id]) {
+            this.observeActiveTurn();
+            return;
+        }
+        if (!turn?.accepted)
+            return;
+        // Idle outcome survives shutdown, and /event has no replay. Recover the latest
+        // durable execution even when its start or terminal was lost across reconnect.
+        const execution = await this.readExecution();
+        if (revision !== this.revision) {
+            this.dirty = true;
+            return;
+        }
+        if (!execution)
+            return;
+        this.execution = execution;
+        this.sequence = execution.durable.seq;
+        if (execution.type === "session.execution.started" ||
+            (execution.type === "session.execution.interrupted" && execution.data.reason === "shutdown"))
+            return;
+        // Read the final history only after observing idle. Never turn an observation transport error into an execution failure.
+        const snapshot = await this.options.reconcile();
+        if (revision !== this.revision) {
+            this.dirty = true;
+            return;
+        }
+        try {
+            this.finish(turn, snapshot, execution);
+        }
+        catch (error) {
+            if (this.turn === turn)
+                this.fail(new Error(toDiagnosticErrorMessage(error)));
+        }
+    }
     async dispatch(input, options, output) {
         const command = input.text.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/);
         if (command?.[1] === "compact" || command?.[1] === "summarize") {
@@ -104,50 +223,41 @@ export class SessionTurns {
             },
         });
     }
-    async finish(id) {
-        await this.options
-            .client()
-            .session.wait({ sessionID: this.options.id }, { signal: this.options.signal });
-        const { info, history } = await this.options.reconcile();
-        if (this.turn?.id !== id)
-            return;
-        if (info.outcome !== "failed" && info.outcome !== "interrupted")
-            this.turn.output?.assert(history);
-        const failure = info.outcome === "failed" ? (this.executionError ?? (await this.readExecutionError())) : null;
-        if (this.turn?.id !== id)
-            return;
-        this.turn = null;
-        if (info.outcome === "interrupted")
+    finish(turn, { info, history }, execution) {
+        if (execution.type === "session.execution.succeeded")
+            turn.output?.assert(history);
+        this.release(turn);
+        if (execution.type === "session.execution.interrupted")
             this.options.emit({
                 type: "turn_canceled",
                 provider: "opencode",
-                turnId: id,
+                turnId: turn.id,
                 reason: "OpenCode interrupted execution",
             });
-        else if (info.outcome === "failed")
+        else if (execution.type === "session.execution.failed")
             this.options.emit({
                 type: "turn_failed",
                 provider: "opencode",
-                turnId: id,
-                error: failure ?? "OpenCode execution failed",
+                turnId: turn.id,
+                error: execution.data.error.message,
             });
         else
             this.options.emit({
                 type: "turn_completed",
                 provider: "opencode",
-                turnId: id,
+                turnId: turn.id,
                 usage: usageFromV2(info),
             });
     }
-    async readExecutionError() {
-        let message = "OpenCode execution failed";
+    async readExecution() {
+        let execution = this.execution;
         for await (const event of this.options
             .client()
-            .session.log({ sessionID: this.options.id, follow: false }, { signal: this.options.signal })) {
-            if (event.type === "session.execution.failed")
-                message = event.data.error.message;
+            .session.log({ sessionID: this.options.id, follow: false, after: this.sequence }, { signal: this.options.signal })) {
+            if (isExecutionEvent(event) && event.durable.seq > (execution?.durable.seq ?? this.sequence))
+                execution = event;
         }
-        return message;
+        return execution;
     }
     promptInput(prompt) {
         if (typeof prompt === "string")
@@ -187,6 +297,7 @@ export class SessionTurns {
                 // A stop sent before the queued prompt is accepted would interrupt an idle session.
                 await turn?.submitted;
                 await this.options.client().session.interrupt({ sessionID: this.options.id });
+                await this.reconcile();
                 await turn?.completion;
             })();
             this.stopping = stop;
@@ -203,24 +314,9 @@ export class SessionTurns {
             await this.stopping;
     }
     observeActiveTurn() {
-        if (this.turn)
+        if (this.turn || this.options.signal.aborted)
             return;
-        const id = randomUUID();
-        const completion = Promise.resolve()
-            .then(() => this.finish(id))
-            .catch((error) => {
-            if (this.turn?.id !== id)
-                return;
-            this.turn = null;
-            this.options.emit({
-                type: "turn_failed",
-                provider: "opencode",
-                turnId: id,
-                error: toDiagnosticErrorMessage(error),
-            });
-        });
-        this.turn = { id, submitted: Promise.resolve(), completion };
-        this.options.emit({ type: "turn_started", provider: "opencode", turnId: id });
+        this.createTurn(Promise.resolve(), true);
     }
 }
 //# sourceMappingURL=turns.js.map

package/dist/server/server/agent/providers/opencode/v2/usage.d.ts

@@ -0,0 +1,21 @@
+import type { OpenCodeEvent, SessionInfo } from "@opencode/client";
+import type { AgentStreamEvent } from "../../../agent-sdk-types.js";
+import type { V2Api } from "./api.js";
+interface UsageOptions {
+    client(): V2Api;
+    cwd: string;
+    info(): SessionInfo;
+    emit(event: AgentStreamEvent): void;
+    reportError(error: unknown): void;
+}
+export declare class SessionUsage {
+    private readonly options;
+    private readonly limits;
+    private reports;
+    constructor(options: UsageOptions);
+    observe(event: OpenCodeEvent): void;
+    private report;
+    private contextLimit;
+}
+export {};
+//# sourceMappingURL=usage.d.ts.map

package/dist/server/server/agent/providers/opencode/v2/usage.js

@@ -0,0 +1,48 @@
+import { usageFromV2 } from "./mapping.js";
+// A step is one model call, so its tokens are the context that call used.
+function contextWindowUsedTokens(tokens) {
+    return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write;
+}
+export class SessionUsage {
+    constructor(options) {
+        this.options = options;
+        this.limits = new Map();
+        this.reports = Promise.resolve();
+    }
+    observe(event) {
+        if (event.type !== "session.step.ended")
+            return;
+        const { tokens } = event.data;
+        // Reports stay in step order while a model's context limit is still being looked up.
+        this.reports = this.reports
+            .then(() => this.report(tokens))
+            .catch((error) => this.options.reportError(error));
+    }
+    async report(tokens) {
+        const model = this.options.info().model;
+        const contextWindowMaxTokens = model ? await this.contextLimit(model) : undefined;
+        this.options.emit({
+            type: "usage_updated",
+            provider: "opencode",
+            usage: {
+                ...usageFromV2(this.options.info()),
+                contextWindowUsedTokens: contextWindowUsedTokens(tokens),
+                ...(contextWindowMaxTokens === undefined ? {} : { contextWindowMaxTokens }),
+            },
+        });
+    }
+    contextLimit(model) {
+        const key = `${model.providerID}/${model.id}`;
+        const cached = this.limits.get(key);
+        if (cached)
+            return cached;
+        const limit = this.options
+            .client()
+            .model.list({ location: { directory: this.options.cwd } })
+            .then((catalog) => catalog.data.find((entry) => entry.providerID === model.providerID && entry.id === model.id)?.limit.context);
+        this.limits.set(key, limit);
+        limit.catch(() => this.limits.delete(key));
+        return limit;
+    }
+}
+//# sourceMappingURL=usage.js.map

package/dist/server/server/agent/providers/opencode-agent.js

@@ -2529,12 +2529,36 @@ class OpenCodeAgentSession {
             sessionId: this.sessionId,
             model: this.config.model ?? null,
             modeId: this.currentMode,
+            thinkingOptionId: this.config.thinkingOptionId ?? null,
         };
     }
     async setModel(modelId) {
+        await this.reconnectIfServerExited();
         const normalizedModelId = typeof modelId === "string" && modelId.trim().length > 0 ? modelId : null;
+        let variant = this.config.thinkingOptionId;
+        if (!normalizedModelId) {
+            variant = undefined;
+        }
+        else if (variant) {
+            const model = this.parseModel(normalizedModelId);
+            const response = await this.client.provider.list({ directory: this.config.cwd });
+            if (response.error)
+                throw new Error(`Failed to fetch OpenCode providers: ${JSON.stringify(response.error)}`);
+            const provider = response.data?.all.find((entry) => entry.id === model?.providerID);
+            const target = model && provider?.models[model.modelID];
+            if (!target)
+                throw new Error(`OpenCode model unavailable: ${normalizedModelId}`);
+            if (!Object.hasOwn(target.variants ?? {}, variant))
+                variant = undefined;
+        }
         this.config.model = normalizedModelId ?? undefined;
+        this.config.thinkingOptionId = variant;
         this.selectedModelContextWindowMaxTokens = this.resolveConfiguredModelContextWindowMaxTokens(this.config.model);
+        this.notifySubscribers({
+            type: "thinking_option_changed",
+            provider: "opencode",
+            thinkingOptionId: variant ?? null,
+        });
     }
     async setThinkingOption(thinkingOptionId) {
         const normalizedThinkingOptionId = normalizeOpenCodeVariantId(thinkingOptionId);

package/dist/server/server/agent/tools/paseo-tools.js

@@ -14,7 +14,7 @@ import { everyMsToFiveFieldCron } from "@getpaseo/protocol/schedule/cadence";
 import { expandUserPath, isSameOrDescendantPath, resolvePathFromBase } from "../../path-utils.js";
 import { ScheduleRunSchema, ScheduleSummarySchema, StoredScheduleSchema, } from "@getpaseo/protocol/schedule/types";
 import { AgentModelSchema, AgentProviderEnum, AgentStatusEnum, ProviderModeSchema, ProviderSummarySchema, parseDurationString, resolveRequiredProviderModel, sanitizePermissionRequest, serializeSnapshotWithMetadata, toScheduleSummary, waitForAgentWithTimeout, } from "../mcp-shared.js";
-import { sendPromptToAgent, setupFinishNotification } from "../agent-prompt.js";
+import { sendPromptToAgent, setupFinishNotification, waitForAgentRunStartWithTimeout, } from "../agent-prompt.js";
 import { respondToAgentPermission } from "../permission-response.js";
 import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, setAgentModeCommand, updateAgentCommand, } from "../lifecycle-command.js";
 import { resolveWorktreeSourceCwd } from "../../workspace-source.js";
@@ -1420,7 +1420,7 @@ export function createPaseoToolCatalog(options) {
             });
             return true;
         }
-        await sendPromptToAgent({
+        const { disposition } = await sendPromptToAgent({
             agentManager,
             agentStorage,
             agentId,
@@ -1453,8 +1453,10 @@ export function createPaseoToolCatalog(options) {
             return response;
         }
         const notifying = armFinishNotification();
-        // Return immediately if background=true
-        // Re-fetch snapshot since the state may have changed
+        // Return once the provider has accepted the turn, so the status reports it running.
+        if (disposition === "turn_started") {
+            await waitForAgentRunStartWithTimeout(agentManager, agentId);
+        }
         const currentSnapshot = agentManager.getAgent(agentId);
         const responseData = {
             success: true,

package/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-bridge-9da07adb97f5e0eb726f7762afee43f5.js → desktop-attachment-bridge-9b9ae7a48611e7619ae3dcfc5573a81d.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5083,[4432,4433]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5084,[4432,4433]);

package/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-store-d5d3402a752965d3037191484127123b.js → desktop-attachment-store-850db74e505f3e0b8091b8a319bf6d95.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5082,[4426]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5083,[4426]);