return total;

}

getPendingCountForSession(actorKey: string): number {

return this.pendingBySession.get(actorKey) ?? 0;

}

async run<T>(actorKey: string, op: () => Promise<T>): Promise<T> {

return this.queue.enqueue(actorKey, op, {

onEnqueue: () => {

};

}

/** Creates status and duplicate-guard action helpers for a media generation task type. */

/** Creates status action helpers for a media generation task type. */

export function createMediaGenerateTaskStatusActions<Task>(params: {

inactiveText: string;

findActiveTask: (sessionKey?: string) => Task | undefined;

buildStatusDetails: params.buildStatusDetails,

});

},

createDuplicateGuardResult(sessionKey?: string): MediaGenerateActionResult | undefined {

return createMediaGenerateDuplicateGuardResult({

sessionKey,

findActiveTask: params.findActiveTask,

buildStatusText: params.buildStatusText,

buildStatusDetails: params.buildStatusDetails,

});

},

};

}

},

};

}

function createMediaGenerateDuplicateGuardResult<Task>(params: {

sessionKey?: string;

findActiveTask: (sessionKey?: string) => Task | undefined;

buildStatusText: TaskStatusTextBuilder<Task>;

buildStatusDetails: (task: Task) => Record<string, unknown>;

}): MediaGenerateActionResult | undefined {

const activeTask = params.findActiveTask(params.sessionKey);

if (!activeTask) {

return undefined;

}

// Duplicate guard returns the active status payload so callers can show current progress.

return {

content: [

{

type: "text",

text: params.buildStatusText(activeTask, { duplicateGuard: true }),

},

],

details: {

action: "status",

duplicateGuard: true,

...params.buildStatusDetails(activeTask),

},

};

}

[commandName]: value,

};

}

export const testing = {

resetPrecomputedRootHelpTextForTests(): void {

precomputedRootHelpText = undefined;

precomputedBrowserHelpText = undefined;

precomputedSecretsHelpText = undefined;

precomputedNodesHelpText = undefined;

precomputedSubcommandHelpText = undefined;

},

};

export { testing as __testing };

return session ? { session, sessionDir: dir } : undefined;

}

/** Append an utterance by session id, creating a dated session directory if needed. */

async appendUtterance(sessionId: string, utterance: TranscriptUtterance): Promise<void> {

const dir =

(await this.findSessionDir(sessionId)) ??

path.join(this.rootDir, dateSegment(sessionId), safeSegment(sessionId));

await this.appendUtteranceToDir(dir, sessionId, utterance);

}

/** Append an utterance for an exact session descriptor. */

async appendUtteranceForSession(

session: TranscriptSessionDescriptor,

return await this.readUtterancesFromDir(sessionDir, options);

}

/** Read utterances by session id or qualified date/id selector. */

async readUtterances(

sessionId: string,

options: { maxUtterances?: number } = {},

): Promise<TranscriptUtterance[]> {

const dir = await this.findSessionDir(sessionId);

if (!dir) {

return [];

}

return await this.readUtterancesFromDir(dir, options);

}

private async readUtterancesFromDir(

dir: string,

options: { maxUtterances?: number } = {},

return component;

}

updateToolArgs(toolCallId: string, args: unknown) {

const existing = this.toolById.get(toolCallId);

if (!existing) {

return;

}

existing.setArgs(args);

}

updateToolResult(

toolCallId: string,

result: unknown,