@borgee/agents-host 0.2.74 → 0.2.94

package/dist/policy/authorization-audit.d.ts

@@ -1,6 +1,6 @@
 import type { DebugLogger } from '../debug.js';
 import type { InternalPolicyMode } from '../compatibility-gates.js';
-export type AuthorizationAuditSurface = 'copilot-acp-permission' | 'localhost-gateway';
+export type AuthorizationAuditSurface = 'copilot-acp-permission' | 'copilot-sdk-permission' | 'localhost-gateway';
 export interface AuthorizationAuditRecord {
     timestamp: string;
     surface: AuthorizationAuditSurface;

package/dist/policy/copilot-permission.d.ts

@@ -1,7 +1,9 @@
 import type { RequestPermissionRequest, RequestPermissionResponse } from '@agentclientprotocol/sdk';
+import type { PermissionRequest as CopilotSdkPermissionRequest, PermissionRequestResult as CopilotSdkPermissionRequestResult } from '@github/copilot-sdk';
 import type { DebugLogger } from '../debug.js';
 import type { InternalPolicyMode } from '../compatibility-gates.js';
 import type { AuthorizationAuditSinkLike } from './authorization-audit.js';
+import type { AuthorizationAuditSurface } from './authorization-audit.js';
 export interface CopilotPermissionPolicyContext {
     gateEnabled: boolean;
     policyMode: InternalPolicyMode;
@@ -10,7 +12,14 @@ export interface CopilotPermissionPolicyContext {
     auditSink?: AuthorizationAuditSinkLike;
     agentId?: string;
     channelId?: string;
+    sessionBound?: boolean;
     toolPermissionMode?: 'default' | 'deny-all';
+    auditSurface?: AuthorizationAuditSurface;
+}
+export interface CopilotSdkPermissionPolicyContext extends Omit<CopilotPermissionPolicyContext, 'params'> {
+    request: CopilotSdkPermissionRequest;
+    sessionId: string;
 }
 export declare function resolveCopilotPermissionResponse(context: CopilotPermissionPolicyContext): RequestPermissionResponse;
+export declare function resolveCopilotSdkPermissionResponse(context: CopilotSdkPermissionPolicyContext): CopilotSdkPermissionRequestResult;
 export declare function createLegacyMissingAllowOptionError(): Error;

package/dist/policy/copilot-permission.js

@@ -1,5 +1,8 @@
 import { summarizeError } from '../debug.js';
 const LEGACY_MISSING_ALLOW_OPTION_MESSAGE = 'Copilot ACP requested permission but did not offer an allow option';
+const SDK_APPROVE_FOR_SESSION_OPTION_ID = 'sdk-approve-for-session';
+const SDK_APPROVE_ONCE_OPTION_ID = 'sdk-approve-once';
+const SDK_REJECT_OPTION_ID = 'sdk-reject';
 function legacySelectPermissionOption(options) {
     const option = options.find((candidate) => candidate.kind === 'allow_always')
         ?? options.find((candidate) => candidate.kind === 'allow_once');
@@ -71,7 +74,7 @@ function decisionToResponse(decision) {
 function appendAuditRecord(context, effectiveDecision, reason, policyDecision) {
     context.auditSink?.append({
         timestamp: new Date().toISOString(),
-        surface: 'copilot-acp-permission',
+        surface: context.auditSurface ?? 'copilot-acp-permission',
         policyMode: context.policyMode,
         effectiveOutcome: effectiveDecision?.outcome ?? 'error',
         reason,
@@ -84,6 +87,30 @@ function appendAuditRecord(context, effectiveDecision, reason, policyDecision) {
     });
 }
 export function resolveCopilotPermissionResponse(context) {
+    if (context.sessionBound === false) {
+        const rejectOption = resolveRejectOption(context.params.options);
+        const unboundDecision = rejectOption
+            ? {
+                outcome: 'selected',
+                optionId: rejectOption.optionId,
+                optionKind: rejectOption.kind,
+                reason: 'unbound-session',
+                toolKind: normalizeToolKind(context.params.toolCall.kind),
+            }
+            : {
+                outcome: 'cancelled',
+                reason: 'unbound-session',
+                toolKind: normalizeToolKind(context.params.toolCall.kind),
+            };
+        context.logger.error('Copilot ACP permission request rejected for an unbound session', {
+            agentId: context.agentId,
+            sessionId: context.params.sessionId,
+            toolKind: unboundDecision.toolKind,
+            reason: unboundDecision.reason,
+        });
+        appendAuditRecord(context, unboundDecision, unboundDecision.reason, unboundDecision);
+        return decisionToResponse(unboundDecision);
+    }
     if (context.toolPermissionMode === 'deny-all') {
         const rejectOption = resolveRejectOption(context.params.options);
         const deniedDecision = rejectOption
@@ -206,6 +233,98 @@ export function resolveCopilotPermissionResponse(context) {
         return decisionToResponse(failedClosedDecision);
     }
 }
+function sdkPermissionToolKind(request) {
+    switch (request.kind) {
+        case 'read':
+            return 'read';
+        case 'write':
+            return 'edit';
+        case 'shell':
+            return 'execute';
+        case 'url':
+            return 'fetch';
+        default:
+            return 'other';
+    }
+}
+function sdkPermissionTitle(request) {
+    if ('fullCommandText' in request && typeof request.fullCommandText === 'string') {
+        return request.fullCommandText;
+    }
+    if ('fileName' in request && typeof request.fileName === 'string') {
+        return request.fileName;
+    }
+    if ('toolName' in request && typeof request.toolName === 'string') {
+        return request.toolName;
+    }
+    return request.kind;
+}
+export function resolveCopilotSdkPermissionResponse(context) {
+    if (context.request.managedApprovalRequired === true) {
+        context.auditSink?.append({
+            timestamp: new Date().toISOString(),
+            surface: context.auditSurface ?? 'copilot-sdk-permission',
+            policyMode: context.policyMode,
+            effectiveOutcome: 'rejected',
+            reason: 'managed-approval-required',
+            agentId: context.agentId,
+            channelId: context.channelId,
+            selectedOptionKind: 'reject_once',
+            policyOutcome: 'selected',
+            policySelectedOptionKind: 'reject_once',
+            toolKind: sdkPermissionToolKind(context.request),
+        });
+        return {
+            kind: 'reject',
+            feedback: 'Managed policy requires interactive approval, which this hosted runtime cannot provide.',
+        };
+    }
+    const options = [
+        {
+            optionId: SDK_APPROVE_FOR_SESSION_OPTION_ID,
+            name: 'Allow for this session',
+            kind: 'allow_always',
+        },
+        {
+            optionId: SDK_APPROVE_ONCE_OPTION_ID,
+            name: 'Allow once',
+            kind: 'allow_once',
+        },
+        {
+            optionId: SDK_REJECT_OPTION_ID,
+            name: 'Reject',
+            kind: 'reject_once',
+        },
+    ];
+    const response = resolveCopilotPermissionResponse({
+        ...context,
+        params: {
+            sessionId: context.sessionId,
+            toolCall: {
+                toolCallId: requestToolCallId(context.request),
+                title: sdkPermissionTitle(context.request),
+                kind: sdkPermissionToolKind(context.request),
+            },
+            options,
+        },
+    });
+    if (response.outcome.outcome !== 'selected') {
+        return { kind: 'reject' };
+    }
+    switch (response.outcome.optionId) {
+        case SDK_APPROVE_FOR_SESSION_OPTION_ID:
+            return { kind: 'approve-for-session' };
+        case SDK_APPROVE_ONCE_OPTION_ID:
+            return { kind: 'approve-once' };
+        default:
+            return { kind: 'reject' };
+    }
+}
+function requestToolCallId(request) {
+    return 'toolCallId' in request && typeof request.toolCallId === 'string'
+        ? request.toolCallId
+        : 'copilot-sdk-permission';
+}
 export function createLegacyMissingAllowOptionError() {
     return new Error(LEGACY_MISSING_ALLOW_OPTION_MESSAGE);
 }

package/dist/progress-to-activity.d.ts

@@ -2,7 +2,7 @@ import type { AgentActivity } from './plugin-sdk.js';
 import type { ProviderProgressUpdate } from './types.js';
 /** Everything a provider reports. The turn boundary is the reporter's own and never arrives here. */
 export type ReportedActivity = Exclude<AgentActivity, {
-    shape: 'turn';
+    shape: 'turn' | 'background_run';
 }>;
 /**
  * Restates one progress update in the rail's own vocabulary.

package/dist/progress-to-activity.js

@@ -19,6 +19,7 @@ export function toReportedActivity(update) {
         case 'activity':
             return { shape: 'activity', ...update.activity };
         case 'compaction':
+        case 'background_run':
             return null;
     }
 }

package/dist/providers/claude/adapter.d.ts

@@ -7,7 +7,8 @@ export declare class ClaudeProviderAdapter implements ProviderAdapter {
     private readonly cli;
     private readonly turnPreparer;
     readonly capabilities: import("../provider-adapter.js").ProviderCapabilities;
-    constructor(cli: ClaudeCliClient, turnPreparer: ProviderTurnPreparer);
+    readonly cancelBackgroundRun?: (channelId: string, providerRunId: string) => Promise<boolean>;
+    constructor(cli: ClaudeCliClient, turnPreparer: Pick<ProviderTurnPreparer, 'prepare'>);
     generateReply(input: ProviderInput, options?: ProviderGenerateOptions): Promise<ProviderReply>;
     cancelTurn(channelId: string): Promise<boolean>;
     dispose(): Promise<void>;

package/dist/providers/claude/adapter.js

@@ -7,14 +7,49 @@ export const CLAUDE_HOSTED_PROVIDER_CAPABILITIES = createHostedProviderCapabilit
         reason: 'real-media-delivered',
         delivery: ['blob'],
     },
+    progressUpdates: {
+        support: 'supported',
+    },
+    backgroundRuns: {
+        lifecycle: 'supported',
+        targetedCancellation: 'supported',
+    },
+    foregroundHandoff: {
+        support: 'not-supported',
+    },
 });
 export class ClaudeProviderAdapter {
     cli;
     turnPreparer;
-    capabilities = CLAUDE_HOSTED_PROVIDER_CAPABILITIES;
+    capabilities;
+    cancelBackgroundRun;
     constructor(cli, turnPreparer) {
         this.cli = cli;
         this.turnPreparer = turnPreparer;
+        const targetedCancellationSupported = cli.targetedBackgroundRunCancellationConfigured;
+        this.capabilities = targetedCancellationSupported
+            ? CLAUDE_HOSTED_PROVIDER_CAPABILITIES
+            : createHostedProviderCapabilities({
+                imageInputTransport: {
+                    source: 'transport-derived',
+                    support: 'supported',
+                    reason: 'real-media-delivered',
+                    delivery: ['blob'],
+                },
+                progressUpdates: {
+                    support: 'supported',
+                },
+                backgroundRuns: {
+                    lifecycle: 'supported',
+                    targetedCancellation: 'not-supported',
+                },
+                foregroundHandoff: {
+                    support: 'not-supported',
+                },
+            });
+        if (targetedCancellationSupported) {
+            this.cancelBackgroundRun = (channelId, providerRunId) => (this.cli.cancelBackgroundRun(channelId, providerRunId));
+        }
     }
     async generateReply(input, options) {
         const preparedTurn = await this.turnPreparer.prepare(input);

package/dist/providers/claude/background-run-observer.d.ts

@@ -0,0 +1,32 @@
+import type { ProviderGenerateOptions } from '../../types.js';
+export declare class ClaudeBackgroundRunObserver {
+    private onProgress?;
+    private readonly limits;
+    private readonly tasks;
+    private readonly emitted;
+    private backgroundTasksActive;
+    constructor(onProgress?: ProviderGenerateOptions['onProgress'], limits?: {
+        terminalRetentionMs?: number;
+        maxTrackedTasks?: number;
+        onBackgroundTasksActiveChanged?: (active: boolean) => void;
+        targetedCancellationSupported?: boolean;
+    });
+    setOnProgress(onProgress?: ProviderGenerateOptions['onProgress']): void;
+    dispose(): void;
+    fail(reason?: string): void;
+    consume(value: unknown): boolean;
+    private getOrCreate;
+    private mapTaskStatus;
+    private isConcreteTerminal;
+    private scheduleMissing;
+    private cancelMissing;
+    private scheduleRetention;
+    private cancelRetention;
+    private touch;
+    private enforceLimit;
+    private isTerminal;
+    private deleteTask;
+    private publish;
+    private reconcileBackgroundTasksActive;
+    private setBackgroundTasksActive;
+}

package/dist/providers/claude/background-run-observer.js

@@ -0,0 +1,381 @@
+const MISSING_TASK_GRACE_MS = 250;
+const TERMINAL_TASK_RETENTION_MS = 30_000;
+const MAX_TRACKED_TASKS = 256;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readOptionalString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function parseClaudeTaskLifecycleUpdate(value) {
+    if (!isRecord(value) ||
+        value.sessionUpdate !== 'session_info_update' ||
+        !isRecord(value._meta) ||
+        !isRecord(value._meta.claudeCode) ||
+        !isRecord(value._meta.claudeCode.taskLifecycle)) {
+        return null;
+    }
+    return parseClaudeTaskLifecycleRecord(value._meta.claudeCode.taskLifecycle);
+}
+export class ClaudeBackgroundRunObserver {
+    onProgress;
+    limits;
+    tasks = new Map();
+    emitted = new Map();
+    backgroundTasksActive = false;
+    constructor(onProgress, limits = {}) {
+        this.onProgress = onProgress;
+        this.limits = limits;
+    }
+    setOnProgress(onProgress) {
+        if (onProgress) {
+            this.onProgress = onProgress;
+        }
+    }
+    dispose() {
+        for (const taskId of [...this.tasks.keys()]) {
+            this.deleteTask(taskId);
+        }
+        this.emitted.clear();
+        this.onProgress = undefined;
+        this.setBackgroundTasksActive(false);
+    }
+    fail(reason = 'Claude background run state is unknown because the provider session ended unexpectedly') {
+        for (const [taskId, record] of this.tasks) {
+            if (!record.background || this.isTerminal(record.state)) {
+                continue;
+            }
+            this.cancelMissing(record);
+            record.state = 'unknown';
+            record.reason = reason;
+            this.publish(taskId, record);
+        }
+        this.dispose();
+    }
+    consume(value) {
+        const update = parseClaudeTaskLifecycleUpdate(value);
+        if (!update) {
+            return false;
+        }
+        if (update.event === 'background_tasks_changed') {
+            const liveTaskIds = new Set(update.tasks.map((task) => task.taskId));
+            for (const [taskId, record] of this.tasks) {
+                if (record.background && !this.isConcreteTerminal(record.state)) {
+                    if (liveTaskIds.has(taskId)) {
+                        this.cancelMissing(record);
+                    }
+                    else {
+                        this.scheduleMissing(taskId, record);
+                    }
+                }
+            }
+            for (const task of update.tasks) {
+                const record = this.getOrCreate(task.taskId, task.description);
+                record.label = task.description;
+                record.background = true;
+                this.cancelMissing(record);
+                if (record.state === 'unknown') {
+                    record.state = 'running';
+                    record.reason = undefined;
+                    this.cancelRetention(record);
+                }
+                this.touch(task.taskId, record);
+                this.publish(task.taskId, record);
+            }
+            this.enforceLimit();
+            this.reconcileBackgroundTasksActive();
+            return true;
+        }
+        const record = this.getOrCreate(update.taskId, update.event === 'started' ? update.description : 'Claude background task');
+        switch (update.event) {
+            case 'started':
+                record.label = update.description;
+                if (update.toolUseId) {
+                    record.parentActivityId = update.toolUseId;
+                }
+                this.cancelRetention(record);
+                this.touch(update.taskId, record);
+                if (record.background) {
+                    this.publish(update.taskId, record);
+                }
+                this.enforceLimit();
+                this.reconcileBackgroundTasksActive();
+                return true;
+            case 'updated':
+                if (update.patch.description) {
+                    record.label = update.patch.description;
+                }
+                if (update.patch.is_backgrounded === true) {
+                    record.background = true;
+                }
+                if (update.patch.status) {
+                    const wasUnknown = record.state === 'unknown';
+                    record.state = this.mapTaskStatus(update.patch.status);
+                    this.cancelMissing(record);
+                    if (wasUnknown && !this.isConcreteTerminal(record.state)) {
+                        record.reason = undefined;
+                    }
+                    if (this.isConcreteTerminal(record.state)) {
+                        this.scheduleRetention(update.taskId, record);
+                    }
+                    else {
+                        this.cancelRetention(record);
+                    }
+                }
+                if (update.patch.error) {
+                    record.reason = update.patch.error;
+                }
+                if (record.background) {
+                    this.publish(update.taskId, record);
+                }
+                this.touch(update.taskId, record);
+                this.enforceLimit();
+                this.reconcileBackgroundTasksActive();
+                return true;
+            case 'notification':
+                if (update.toolUseId) {
+                    record.parentActivityId = update.toolUseId;
+                }
+                record.state =
+                    update.status === 'completed'
+                        ? 'completed'
+                        : update.status === 'failed'
+                            ? 'failed'
+                            : 'cancelled';
+                this.cancelMissing(record);
+                if (update.status !== 'completed' && update.summary.trim().length > 0) {
+                    record.reason = update.summary;
+                }
+                this.scheduleRetention(update.taskId, record);
+                if (record.background) {
+                    this.publish(update.taskId, record);
+                }
+                this.touch(update.taskId, record);
+                this.enforceLimit();
+                this.reconcileBackgroundTasksActive();
+                return true;
+        }
+    }
+    getOrCreate(taskId, label) {
+        const existing = this.tasks.get(taskId);
+        if (existing) {
+            this.touch(taskId, existing);
+            return existing;
+        }
+        const record = {
+            label,
+            background: false,
+            missingFromSnapshot: false,
+            state: 'running',
+        };
+        this.tasks.set(taskId, record);
+        return record;
+    }
+    mapTaskStatus(status) {
+        switch (status) {
+            case 'pending':
+            case 'running':
+                return 'running';
+            case 'paused':
+                return 'waiting';
+            case 'completed':
+                return 'completed';
+            case 'failed':
+                return 'failed';
+            case 'killed':
+                return 'cancelled';
+        }
+    }
+    isConcreteTerminal(state) {
+        return state === 'completed' || state === 'failed' || state === 'cancelled';
+    }
+    scheduleMissing(taskId, record) {
+        if (record.missingFromSnapshot) {
+            return;
+        }
+        record.missingFromSnapshot = true;
+        record.missingTimer = setTimeout(() => {
+            record.missingTimer = undefined;
+            if (!record.missingFromSnapshot || this.isConcreteTerminal(record.state)) {
+                return;
+            }
+            record.state = 'unknown';
+            record.reason =
+                'Provider background task disappeared before a terminal lifecycle event was observed';
+            this.publish(taskId, record);
+            this.reconcileBackgroundTasksActive();
+            this.scheduleRetention(taskId, record);
+        }, MISSING_TASK_GRACE_MS);
+    }
+    cancelMissing(record) {
+        record.missingFromSnapshot = false;
+        if (record.missingTimer) {
+            clearTimeout(record.missingTimer);
+            record.missingTimer = undefined;
+        }
+    }
+    scheduleRetention(taskId, record) {
+        this.cancelRetention(record);
+        record.retentionTimer = setTimeout(() => {
+            if (this.tasks.get(taskId) === record) {
+                this.deleteTask(taskId);
+            }
+        }, this.limits.terminalRetentionMs ?? TERMINAL_TASK_RETENTION_MS);
+    }
+    cancelRetention(record) {
+        if (record.retentionTimer) {
+            clearTimeout(record.retentionTimer);
+            record.retentionTimer = undefined;
+        }
+    }
+    touch(taskId, record) {
+        this.tasks.delete(taskId);
+        this.tasks.set(taskId, record);
+    }
+    enforceLimit() {
+        const limit = this.limits.maxTrackedTasks ?? MAX_TRACKED_TASKS;
+        const countsAsHistory = (record) => !record.background || this.isTerminal(record.state);
+        let historySize = [...this.tasks.values()].filter(countsAsHistory).length;
+        while (historySize > limit) {
+            const candidate = [...this.tasks].find(([, record]) => countsAsHistory(record) && !record.retentionTimer);
+            if (!candidate) {
+                // Live identities and terminal enrichment windows are required state.
+                // Their timers converge the temporary history excess after the window.
+                return;
+            }
+            this.deleteTask(candidate[0]);
+            historySize -= 1;
+        }
+    }
+    isTerminal(state) {
+        return this.isConcreteTerminal(state) || state === 'unknown';
+    }
+    deleteTask(taskId) {
+        const record = this.tasks.get(taskId);
+        if (!record) {
+            return;
+        }
+        this.cancelMissing(record);
+        this.cancelRetention(record);
+        this.tasks.delete(taskId);
+        this.emitted.delete(taskId);
+        this.reconcileBackgroundTasksActive();
+    }
+    publish(taskId, record) {
+        if (!this.onProgress) {
+            return;
+        }
+        const run = {
+            providerRunId: taskId,
+            executionId: taskId,
+            label: record.label,
+            state: record.state,
+            ...(record.parentActivityId ? { parentActivityId: record.parentActivityId } : {}),
+            ...(record.reason ? { reason: record.reason } : {}),
+            stopSupported: this.limits.targetedCancellationSupported === true,
+        };
+        const fingerprint = JSON.stringify(run);
+        if (this.emitted.get(taskId) === fingerprint) {
+            return;
+        }
+        this.emitted.set(taskId, fingerprint);
+        this.onProgress({ type: 'background_run', run });
+    }
+    reconcileBackgroundTasksActive() {
+        this.setBackgroundTasksActive([...this.tasks.values()].some((record) => record.background && !this.isTerminal(record.state)));
+    }
+    setBackgroundTasksActive(active) {
+        if (this.backgroundTasksActive === active) {
+            return;
+        }
+        this.backgroundTasksActive = active;
+        this.limits.onBackgroundTasksActiveChanged?.(active);
+    }
+}
+function parseClaudeTaskLifecycleRecord(lifecycle) {
+    const event = lifecycle.event;
+    if (event === 'background_tasks_changed') {
+        if (!Array.isArray(lifecycle.tasks)) {
+            return null;
+        }
+        const tasks = lifecycle.tasks.flatMap((task) => {
+            if (!isRecord(task)) {
+                return [];
+            }
+            const taskId = readOptionalString(task, 'taskId');
+            const taskType = readOptionalString(task, 'taskType');
+            const description = readOptionalString(task, 'description');
+            return taskId && taskType && description ? [{ taskId, taskType, description }] : [];
+        });
+        return tasks.length === lifecycle.tasks.length ? { event, tasks } : null;
+    }
+    const taskId = readOptionalString(lifecycle, 'taskId');
+    if (!taskId) {
+        return null;
+    }
+    if (event === 'started') {
+        const description = readOptionalString(lifecycle, 'description');
+        if (!description) {
+            return null;
+        }
+        const toolUseId = readOptionalString(lifecycle, 'toolUseId');
+        const subagentType = readOptionalString(lifecycle, 'subagentType');
+        const taskType = readOptionalString(lifecycle, 'taskType');
+        return {
+            event,
+            taskId,
+            description,
+            ...(toolUseId ? { toolUseId } : {}),
+            ...(subagentType ? { subagentType } : {}),
+            ...(taskType ? { taskType } : {}),
+        };
+    }
+    if (event === 'updated') {
+        if (!isRecord(lifecycle.patch)) {
+            return null;
+        }
+        const status = readOptionalString(lifecycle.patch, 'status');
+        const validStatuses = new Set([
+            'pending',
+            'running',
+            'completed',
+            'failed',
+            'killed',
+            'paused',
+        ]);
+        if (status !== undefined && !validStatuses.has(status)) {
+            return null;
+        }
+        const description = readOptionalString(lifecycle.patch, 'description');
+        const error = readOptionalString(lifecycle.patch, 'error');
+        return {
+            event,
+            taskId,
+            patch: {
+                ...(status ? { status: status } : {}),
+                ...(description ? { description } : {}),
+                ...(error ? { error } : {}),
+                ...(typeof lifecycle.patch.is_backgrounded === 'boolean'
+                    ? { is_backgrounded: lifecycle.patch.is_backgrounded }
+                    : {}),
+            },
+        };
+    }
+    if (event === 'notification') {
+        const status = readOptionalString(lifecycle, 'status');
+        const summary = readOptionalString(lifecycle, 'summary');
+        if (!summary || (status !== 'completed' && status !== 'failed' && status !== 'stopped')) {
+            return null;
+        }
+        const toolUseId = readOptionalString(lifecycle, 'toolUseId');
+        return {
+            event,
+            taskId,
+            status,
+            summary,
+            ...(toolUseId ? { toolUseId } : {}),
+        };
+    }
+    return null;
+}