mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
413 lines
26 KiB
JavaScript
413 lines
26 KiB
JavaScript
"use strict";
|
|
|
|
const { randomUUID } = require("node:crypto");
|
|
const { PluginRpcError, RPC_ERRORS } = require("../rpcRouter.cjs");
|
|
const { createDefinitionValidator } = require("../contractValidator.cjs");
|
|
const { normalizePermissionDeclarations } = require("../permissionResources.cjs");
|
|
const { PluginAISourceBinding } = require("../ai/sourceBinding.cjs");
|
|
const { DelegatedAgentScopes, isRequestCancellation } = require("./delegatedScope.cjs");
|
|
const { listMcpTools } = require("../../capabilities/codegen/toolSurfaces.cjs");
|
|
const fail = (code) => new PluginRpcError(RPC_ERRORS[code], "Plugin Agent operation unavailable");
|
|
const FEATURE = require("../generated/plugin-contract.schema.json").$defs.PluginAgentFeature.const;
|
|
const CAPABILITIES = Object.freeze(require("../generated/plugin-contract.schema.json").$defs.PluginAgentCapabilities.const);
|
|
const TOOLS = listMcpTools().filter((tool) => CAPABILITIES.includes(tool.capabilityId));
|
|
const ROUTES = [
|
|
["listBackends", "PluginAIEmptyParams", "PluginAgentBackendsResult"],
|
|
["selectTargets", "PluginAIEmptyParams", "PluginAgentTargetsResult"],
|
|
["listChats", "PluginAIEmptyParams", "PluginAgentChatsResult"],
|
|
["openChat", "PluginAgentOpenParams", "PluginAgentChatResult"],
|
|
["send", "PluginAgentSendParams", "PluginAgentTurnResult"],
|
|
["read", "PluginAgentTurnRef", "PluginAgentEvent"],
|
|
["history", "PluginAgentChatRef", "PluginAgentHistoryResult"],
|
|
["stop", "PluginAgentTurnRef", "PluginAIBooleanResult"],
|
|
["closeChat", "PluginAgentChatRef", "PluginAIBooleanResult"],
|
|
];
|
|
|
|
class PluginAgentService {
|
|
constructor(options) {
|
|
this.source = new PluginAISourceBinding(options);
|
|
this.database = options.database;
|
|
this.host = options.hostAdapter;
|
|
this.permission = options.permissionEngine;
|
|
this.store = options.conversationStore;
|
|
this.getSessionBinding = options.getSessionBinding;
|
|
this.getMcpBridge = options.getMcpBridge;
|
|
this.getTargetManager = options.getTargetManager ?? (() => null);
|
|
this.clock = options.clock ?? Date.now;
|
|
this.backends = new Map(); this.selections = new Map(); this.chats = new Map(); this.turns = new Map();
|
|
this.budgets = new Map(); this.pendingOpens = new Set(); this.registrations = []; this.closed = false;
|
|
this.pendingSelections = new Map(); this.startupTurns = new Map(); this.targetManager = null; this.targetSubscriptions = [];
|
|
this.eventValidator = createDefinitionValidator("PluginAgentEvent");
|
|
this.sessionValidator = createDefinitionValidator("PluginAgentHostSession");
|
|
this.scopes = new DelegatedAgentScopes({ resolveOwner: (ctx) => this.#guard(ctx),
|
|
assertHostActive: (ctx) => this.host.assertActive(ctx), clock: this.clock,
|
|
authorizeAction: async (ctx, owner, action, signal) => {
|
|
const decisionContext = { ...ctx, signal, permissionOperation: Object.freeze({}), sourceOwner: owner.privateOwner };
|
|
await this.permission.authorize(decisionContext, {
|
|
permission: "ai.agent.actions", resources: action.targets.length
|
|
? action.targets.map((target) => `agent-target:${target.kind}:${target.id}:${target.owner}:${target.revision}`) : ["*"],
|
|
reason: "Use a delegated Agent tool on selected resources", sessionId: ctx.agentChatId,
|
|
displayContext: { modelLabel: ctx.agentBackendLabel, selections: action.targets.map((target) => ({
|
|
title: ctx.agentTargetLabels.get(target.id) ?? target.id, scope: "session", version: target.revision,
|
|
})), action: { capabilityId: action.capabilityId, text: ctx.agentToolPreview } },
|
|
});
|
|
} });
|
|
this.revocation = this.permission.onDidRevoke((event) => this.releasePlugin(event.pluginId));
|
|
this.hostInvalidation = this.host.onDidInvalidate(() => this.releaseAll());
|
|
}
|
|
|
|
async #guard(context) {
|
|
try {
|
|
if (this.closed) throw fail("unavailable");
|
|
const owner = await this.source.resolve(context);
|
|
await this.host.assertActive(context); this.source.assertCurrent(owner);
|
|
return owner;
|
|
} catch (error) {
|
|
const owner = this.source.bindings.get(context.runtimeId);
|
|
if (!isRequestCancellation(error, context) && owner?.pluginId === context.pluginId
|
|
&& owner.pluginVersion === context.pluginVersion) this.releaseRuntime(context.runtimeId);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
#assertNow(turn) {
|
|
if (this.closed || turn.done || this.turns.get(turn.handle) !== turn || turn.chat.activeTurn !== turn
|
|
|| turn.controller.signal.aborted || turn.chat.expiresAt <= this.clock()
|
|
|| turn.ticket?.controller.signal.aborted
|
|
|| this.host.generation !== turn.chat.hostGeneration) throw fail("cancelled");
|
|
this.source.assertCurrent(turn.owner);
|
|
if (this.host.getSenderId() !== turn.senderId) throw fail("cancelled");
|
|
if (this.permission.getPolicyRevision(this.database.getActivePlugin(turn.owner.pluginId)) !== turn.policyRevision) throw fail("cancelled");
|
|
for (const target of turn.chat.selection.targets) if (!target.isCurrent(target)) throw fail("cancelled");
|
|
}
|
|
|
|
async #chat(params, context) {
|
|
const owner = await this.#guard(context); const chat = this.chats.get(params.chatHandle);
|
|
if (!chat || chat.owner !== owner || chat.expiresAt <= this.clock() || chat.hostGeneration !== this.host.generation) throw fail("permissionDenied");
|
|
return chat;
|
|
}
|
|
async #turn(params, context) {
|
|
const owner = await this.#guard(context); const turn = this.turns.get(params.turnHandle);
|
|
if (!turn || turn.owner !== owner || turn.expiresAt <= this.clock()) throw fail("permissionDenied");
|
|
return turn;
|
|
}
|
|
async #backendCurrent(backend, context) {
|
|
if (backend.expiresAt <= this.clock() || backend.hostGeneration !== this.host.generation
|
|
|| !(await this.host.requestAgent("agent.current", { hostHandle: backend.hostHandle }, context)).current) throw fail("failedPrecondition");
|
|
}
|
|
#prune() {
|
|
for (const map of [this.backends, this.selections]) for (const [key, entry] of map) if (entry.expiresAt <= this.clock()) map.delete(key);
|
|
for (const [key, turn] of this.turns) if (turn.expiresAt <= this.clock()) { this.#end(turn); this.turns.delete(key); }
|
|
for (const [key, chat] of this.chats) if (chat.expiresAt <= this.clock()) {
|
|
this.#forgetChat(chat); this.chats.delete(key);
|
|
}
|
|
}
|
|
#observeTargets() {
|
|
const manager = this.getTargetManager();
|
|
if (manager === this.targetManager) return;
|
|
for (const entry of this.targetSubscriptions) entry.dispose(); this.targetSubscriptions = [];
|
|
this.targetManager = manager;
|
|
const invalidate = () => {
|
|
for (const controller of this.pendingSelections.keys()) controller.abort();
|
|
for (const [key, chat] of this.chats) if (chat.selection.targets.some((target) => !target.isCurrent(target))) {
|
|
this.#forgetChat(chat); this.chats.delete(key);
|
|
}
|
|
};
|
|
invalidate();
|
|
for (const method of ["onSessionOwned", "onSessionClosed", "onWorkerExit"]) {
|
|
if (typeof manager?.[method] === "function") this.targetSubscriptions.push(manager[method](invalidate));
|
|
}
|
|
}
|
|
#charge(owner) {
|
|
const key = JSON.stringify([owner.sourceKey, owner.privateOwner]); const now = this.clock();
|
|
for (const [id, entry] of this.budgets) if (now - entry.start >= 60_000) this.budgets.delete(id);
|
|
const budget = this.budgets.get(key) ?? { start: now, requests: 0 };
|
|
if (budget.requests >= 6 || (!this.budgets.has(key) && this.budgets.size >= 256)) throw fail("resourceExhausted");
|
|
budget.requests++; this.budgets.set(key, budget);
|
|
}
|
|
|
|
registerRpcCapabilities(registry) {
|
|
const startupLifetime = async (_context, next) => next();
|
|
startupLifetime.prepareAuthorization = (context) => {
|
|
if (context.method !== "agent.send") return undefined;
|
|
// Registry cleanup runs after its final authority check. Until then the
|
|
// caller still owns startup cancellation because no handle was delivered.
|
|
return () => {
|
|
const turn = this.startupTurns.get(context.permissionOperation);
|
|
if (!turn) return;
|
|
try {
|
|
if (!turn.handoffReady || context.signal.aborted) throw fail("cancelled");
|
|
this.#assertNow(turn);
|
|
} catch { this.#end(turn); }
|
|
turn.detachStartup();
|
|
};
|
|
};
|
|
this.registrations.push(registry.use(startupLifetime));
|
|
for (const [operation, paramsType, resultType] of ROUTES) {
|
|
const input = createDefinitionValidator(paramsType); const output = createDefinitionValidator(resultType);
|
|
this.registrations.push(registry.registerRequest(`agent.${operation}`, async (params, context) => {
|
|
const result = await this[operation](params, context); await this.#guard(context);
|
|
if (!output(result)) throw fail("internal");
|
|
if (operation === "send") {
|
|
const turn = this.startupTurns.get(context.permissionOperation);
|
|
if (!turn || turn.handle !== result.turnHandle) throw fail("cancelled");
|
|
turn.handoffReady = true;
|
|
}
|
|
return result;
|
|
}, { metadata: { capability: "plugin-agent", mutating: !["listBackends", "listChats", "history", "read"].includes(operation), permission: "ai.agent.use" },
|
|
validateParams: (params) => { if (!input(params)) throw fail("invalidArgument"); return Object.freeze(structuredClone(params)); },
|
|
authorization: async (params, context) => {
|
|
await this.#guard(context);
|
|
const chat = operation === "send" ? await this.#chat(params, context) : null;
|
|
return { permission: "ai.agent.use", resources: ["*"], reason: "Use this plugin's configured global Agent conversation",
|
|
...(operation !== "send" ? { deferDecision: true } : {}),
|
|
...(chat ? { displayContext: { modelLabel: chat.backend.label,
|
|
selections: chat.selection.items.map((item) => ({ title: item.title, scope: "session", version: "selected" })),
|
|
action: { capabilityId: "agent.send", text: params.text } } } : {}),
|
|
};
|
|
},
|
|
}));
|
|
}
|
|
}
|
|
|
|
async listBackends(_params, context) {
|
|
const owner = await this.#guard(context); this.#prune();
|
|
const result = await this.host.requestAgent("agent.backends", {}, context); await this.#guard(context);
|
|
const items = [];
|
|
for (const entry of result.backends) {
|
|
let lease = [...this.backends.values()].find((item) => item.owner === owner && item.hostHandle === entry.hostHandle);
|
|
if (!lease) {
|
|
if (this.backends.size >= 256) throw fail("resourceExhausted");
|
|
lease = { ...entry, backendRef: randomUUID(), owner, hostGeneration: this.host.generation, expiresAt: this.clock() + 300_000 };
|
|
this.backends.set(lease.backendRef, lease);
|
|
}
|
|
const eligible = ["catty", "claude"].includes(entry.backend);
|
|
items.push({ backendRef: lease.backendRef, backend: entry.backend, label: entry.label,
|
|
status: eligible ? entry.status : entry.status === "unavailable" ? "unavailable" : "unsupported",
|
|
reason: eligible || entry.status === "unavailable" ? entry.reason : "native-boundary-unverified" });
|
|
}
|
|
return { items };
|
|
}
|
|
|
|
async selectTargets(_params, context) {
|
|
const owner = await this.#guard(context); this.#prune();
|
|
this.#observeTargets();
|
|
if (this.selections.size >= 64) throw fail("resourceExhausted");
|
|
const controller = new AbortController(); this.pendingSelections.set(controller, owner);
|
|
let result;
|
|
try {
|
|
result = await this.host.requestAgent("agent.targets", {}, { ...context,
|
|
signal: context.signal ? AbortSignal.any([controller.signal, context.signal]) : controller.signal });
|
|
await this.#guard(context); controller.signal.throwIfAborted();
|
|
} finally { this.pendingSelections.delete(controller); }
|
|
const targets = result.targets.map((item) => {
|
|
const binding = this.getSessionBinding(item.sessionId);
|
|
if (!binding || !binding.isCurrent(binding)) throw fail("failedPrecondition");
|
|
return Object.freeze({ ...binding, kind: "terminal", id: item.sessionId });
|
|
});
|
|
if (new Set(targets.map((target) => target.id)).size !== targets.length) throw fail("invalidArgument");
|
|
const selectionHandle = randomUUID(); const expiresAt = this.clock() + 300_000;
|
|
const items = result.targets.map((item) => ({ kind: "terminal", title: item.label }));
|
|
this.selections.set(selectionHandle, { owner, targets, terminalSessions: structuredClone(result.targets), items, expiresAt });
|
|
return { selectionHandle, expiresAt, items };
|
|
}
|
|
|
|
async listChats(_params, context) {
|
|
const owner = await this.#guard(context);
|
|
const rows = await this.store.list(owner, () => this.#guard(context));
|
|
return { items: rows.map((row) => ({ conversationRef: row.conversationRef, title: row.title, backend: row.agentId, updatedAt: row.updatedAt })) };
|
|
}
|
|
|
|
async openChat(params, context) {
|
|
const owner = await this.#guard(context); this.#prune();
|
|
const backend = this.backends.get(params.backendRef); const selection = this.selections.get(params.selectionHandle);
|
|
if (!backend || backend.owner !== owner || !["catty", "claude"].includes(backend.backend) || backend.status !== "supported"
|
|
|| !selection || selection.owner !== owner || selection.expiresAt <= this.clock()) throw fail("permissionDenied");
|
|
if (this.chats.size + this.pendingOpens.size >= 64 || [...this.chats.values()].filter((chat) => chat.owner === owner).length >= 8) throw fail("resourceExhausted");
|
|
if (params.conversationRef && [...this.pendingOpens].some((item) => item.owner === owner && item.conversationRef === params.conversationRef)) throw fail("alreadyExists");
|
|
const opening = { owner, conversationRef: params.conversationRef, active: true }; this.pendingOpens.add(opening); let scope;
|
|
try {
|
|
await this.#backendCurrent(backend, context);
|
|
let record = params.conversationRef ? await this.store.read(owner, params.conversationRef, () => this.#guard(context)) : null;
|
|
if (params.conversationRef && !record) throw fail("notFound");
|
|
if (record && [...this.chats.values()].some((chat) => chat.owner === owner && chat.record.conversationRef === record.conversationRef)) throw fail("alreadyExists");
|
|
const now = this.clock();
|
|
record ??= { conversationRef: randomUUID(), id: `plugin-agent:${randomUUID()}`, title: "Global Agent chat", agentId: backend.backend,
|
|
scope: { type: "global" }, messages: [], createdAt: now, updatedAt: now };
|
|
// Durable conversation identity is conversationRef. A fresh runtime actor
|
|
// never reuses revoked privacy/native/tool state when history is reopened.
|
|
record.id = `plugin-agent:${randomUUID()}`;
|
|
record.agentId = backend.backend; delete record.externalSessionId;
|
|
const declared = normalizePermissionDeclarations(context.manifest).has("ai.agent.actions");
|
|
const capabilities = declared && this.permission.getMode(context, "ai.agent.actions") !== "deny" ? CAPABILITIES : [];
|
|
scope = await this.scopes.issue(context, { backend: { key: backend.backendRef, revision: backend.hostHandle,
|
|
isCurrent: () => backend.expiresAt > this.clock() && backend.hostGeneration === this.host.generation }, targets: selection.targets, capabilities });
|
|
if (!opening.active || await this.#guard(context) !== owner) throw fail("cancelled");
|
|
await this.store.save(owner, record, async () => { if (!opening.active) throw fail("cancelled"); await this.#guard(context); });
|
|
if (!opening.active || await this.#guard(context) !== owner) throw fail("cancelled");
|
|
const chatHandle = randomUUID();
|
|
this.chats.set(chatHandle, { handle: chatHandle, owner, backend, selection, record, scope, capabilities,
|
|
expiresAt: Math.min(scope.expiresAt, selection.expiresAt, backend.expiresAt), hostGeneration: this.host.generation, activeTurn: null, generation: 0 });
|
|
return { chatHandle, conversationRef: record.conversationRef, backendLabel: backend.label,
|
|
expiresAt: this.chats.get(chatHandle).expiresAt };
|
|
} catch (error) { if (scope) this.scopes.discard(scope.handle, owner); throw error; }
|
|
finally { this.pendingOpens.delete(opening); }
|
|
}
|
|
|
|
async #dispatchTool(turn, method, params, execute) {
|
|
this.#assertNow(turn);
|
|
if (++turn.toolCalls > 32) { this.#end(turn, "budget-exceeded"); throw fail("resourceExhausted"); }
|
|
const spec = TOOLS.find((item) => item.rpcMethod === method);
|
|
if (!spec || !turn.chat.capabilities.includes(spec.capabilityId)) throw fail("permissionDenied");
|
|
let ids = [];
|
|
if (spec.capabilityId === "session.environment") ids = turn.chat.selection.targets.map((target) => target.id);
|
|
else if (["terminal.poll", "terminal.stop"].includes(spec.capabilityId)) {
|
|
const id = this.getMcpBridge().getPluginAgentJobTarget(params.jobId, turn.chat.record.id);
|
|
if (!id) throw fail("permissionDenied"); ids = [id];
|
|
} else { if (typeof params.sessionId !== "string") throw fail("invalidArgument"); ids = [params.sessionId]; }
|
|
const targets = ids.map((id) => {
|
|
const target = turn.chat.selection.targets.find((item) => item.id === id);
|
|
if (!target) throw fail("permissionDenied"); return target;
|
|
});
|
|
const preview = JSON.stringify(Object.fromEntries(Object.entries(params).filter(([key]) => !["chatSessionId", "scopedSessionIds"].includes(key))), null, 2);
|
|
if (Buffer.byteLength(preview) > 16_384) throw fail("resourceExhausted");
|
|
const ctx = { ...turn.context, agentChatId: turn.chat.record.id, agentBackendLabel: turn.chat.backend.label,
|
|
agentTargetLabels: new Map(turn.chat.selection.terminalSessions.map((item) => [item.sessionId, item.label])), agentToolPreview: preview };
|
|
try { await this.#backendCurrent(turn.chat.backend, ctx); }
|
|
catch (error) { this.#end(turn, "unavailable"); throw error; }
|
|
return this.scopes.dispatch(turn.ticket, ctx, { capabilityId: spec.capabilityId, targets }, async (execution) => {
|
|
this.#assertNow(turn);
|
|
// Ask may have waited while the configured backend was edited. Check the
|
|
// trusted renderer's current revision again before the selected effect.
|
|
try { await this.#backendCurrent(turn.chat.backend, ctx); }
|
|
catch (error) { this.#end(turn, "unavailable"); throw error; }
|
|
this.#assertNow(turn); const result = await execute(execution); this.#assertNow(turn); return result;
|
|
});
|
|
}
|
|
|
|
async send(params, context) {
|
|
const chat = await this.#chat(params, context); const owner = chat.owner;
|
|
this.#prune();
|
|
if (!params.text.trim()) throw fail("invalidArgument");
|
|
if (this.turns.size >= 256 || chat.activeTurn || Buffer.byteLength(params.text) > 16_384 || chat.record.messages.length > 198) throw fail("resourceExhausted");
|
|
const controller = new AbortController(); const turn = { handle: randomUUID(), owner, chat, controller, context: { ...context, signal: controller.signal },
|
|
done: false, reading: false, bytes: 0, toolCalls: 0, generation: ++chat.generation, expiresAt: this.clock() + 300_000, hostHandle: null,
|
|
policyRevision: this.permission.getPolicyRevision(this.database.getActivePlugin(owner.pluginId)), senderId: this.host.getSenderId() };
|
|
chat.activeTurn = turn; this.turns.set(turn.handle, turn);
|
|
turn.context = { ...context, signal: controller.signal, assertActive: async () => this.#assertNow(turn) };
|
|
const cancelStartup = () => this.#end(turn);
|
|
turn.detachStartup = () => {
|
|
context.signal?.removeEventListener("abort", cancelStartup);
|
|
if (this.startupTurns.get(context.permissionOperation) === turn) this.startupTurns.delete(context.permissionOperation);
|
|
};
|
|
this.startupTurns.set(context.permissionOperation, turn);
|
|
context.signal?.addEventListener("abort", cancelStartup, { once: true });
|
|
try {
|
|
context.signal?.throwIfAborted();
|
|
this.#charge(owner); await this.#backendCurrent(chat.backend, context);
|
|
turn.ticket = await this.scopes.begin(chat.scope.handle, context);
|
|
turn.ticket.controller.signal.addEventListener("abort", () => this.#end(turn), { once: true });
|
|
this.#assertNow(turn);
|
|
const mcp = this.getMcpBridge();
|
|
turn.registration = mcp.registerPluginAgentDelegation(chat.record.id, { turnTag: turn.handle, senderId: turn.senderId,
|
|
tools: TOOLS.filter((tool) => chat.capabilities.includes(tool.capabilityId)).map((tool) => tool.mcpTool),
|
|
assertCurrent: () => this.#assertNow(turn), dispatch: (method, payload, execute) => this.#dispatchTool(turn, method, payload, execute) });
|
|
mcp.setChatSessionCancelled(chat.record.id, false);
|
|
turn.timer = setTimeout(() => this.#end(turn, "budget-exceeded"), Math.max(1, Math.min(120_000, chat.expiresAt - this.clock()))); turn.timer.unref?.();
|
|
const prior = structuredClone(chat.record);
|
|
chat.record.messages.push({ id: randomUUID(), role: "user", content: params.text, timestamp: this.clock() });
|
|
chat.record.updatedAt = this.clock();
|
|
if (chat.record.title === "Global Agent chat") chat.record.title = params.text.trim().split(/\r?\n/u)[0].slice(0, 80);
|
|
prior.title = chat.record.title;
|
|
await this.store.save(owner, chat.record, async () => { await this.#guard(context); this.#assertNow(turn); });
|
|
const result = await this.host.requestAgent("agent.run", { backendHandle: chat.backend.hostHandle, delegationTag: turn.handle,
|
|
session: prior, capabilities: chat.capabilities, terminalSessions: chat.selection.terminalSessions, text: params.text, maxIterations: 12 }, turn.context);
|
|
this.#assertNow(turn); turn.hostHandle = result.hostHandle;
|
|
return { turnHandle: turn.handle, expiresAt: turn.expiresAt };
|
|
} catch (error) { this.#end(turn); throw error; }
|
|
}
|
|
|
|
async read(params, context) {
|
|
const turn = await this.#turn(params, context);
|
|
if (turn.done) return turn.endEvent;
|
|
if (turn.reading) throw fail("alreadyExists"); turn.reading = true;
|
|
try {
|
|
this.#assertNow(turn);
|
|
await this.#backendCurrent(turn.chat.backend, context);
|
|
const result = await this.host.requestAgent("agent.next", { hostHandle: turn.hostHandle },
|
|
{ ...context, signal: AbortSignal.any([context.signal ?? new AbortController().signal, turn.controller.signal]) });
|
|
this.#assertNow(turn);
|
|
if (result.session) {
|
|
if (!this.sessionValidator(result.session) || result.session.id !== turn.chat.record.id
|
|
|| result.session.conversationRef !== turn.chat.record.conversationRef || result.session.agentId !== turn.chat.backend.backend) throw fail("internal");
|
|
turn.chat.record = structuredClone(result.session);
|
|
await this.store.save(turn.owner, turn.chat.record, async () => { await this.#guard(context); this.#assertNow(turn); });
|
|
}
|
|
const event = result.done ? { kind: "end", reason: "completed" } : result.event;
|
|
if (!this.eventValidator(event)) throw fail("internal");
|
|
turn.bytes += Buffer.byteLength(JSON.stringify(event));
|
|
if (turn.bytes > 262_144) throw fail("resourceExhausted");
|
|
if (event.kind === "end") this.#end(turn, event.reason);
|
|
return event;
|
|
} catch (error) { if (turn.done) return turn.endEvent; this.#end(turn, error.code === RPC_ERRORS.resourceExhausted ? "budget-exceeded" : "unavailable"); throw error; }
|
|
finally { turn.reading = false; }
|
|
}
|
|
|
|
async history(params, context) {
|
|
const chat = await this.#chat(params, context); const items = []; let bytes = 0;
|
|
for (const message of [...chat.record.messages].reverse()) {
|
|
if (!["user", "assistant"].includes(message?.role) || typeof message.content !== "string") continue;
|
|
const text = message.content.slice(0, 32_768); bytes += Buffer.byteLength(text);
|
|
if (bytes > 131_072) break; items.unshift({ role: message.role, text });
|
|
}
|
|
return { items };
|
|
}
|
|
|
|
#end(turn, reason = "cancelled") {
|
|
if (turn.done) return;
|
|
const wasCurrent = turn.chat.activeTurn === turn;
|
|
turn.done = true; turn.detachStartup?.(); turn.endEvent = { kind: "end", reason }; clearTimeout(turn.timer); turn.controller.abort();
|
|
if (turn.ticket) this.scopes.finish(turn.ticket);
|
|
turn.registration?.dispose();
|
|
if (wasCurrent) {
|
|
turn.chat.activeTurn = null;
|
|
try { this.getMcpBridge().applyChatSessionCancelled(turn.chat.record.id, true); } catch {}
|
|
}
|
|
if (turn.hostHandle) void this.host.requestAgent("agent.release", { hostHandle: turn.hostHandle },
|
|
// Cleanup authenticates the owning source, independently of the ended
|
|
// turn or its completed Send request. The host still checks app lifetime.
|
|
{ ...turn.context, signal: undefined, assertActive: async () => this.source.assertCurrent(turn.owner) }).catch(() => {});
|
|
}
|
|
async stop(params, context) { const turn = await this.#turn(params, context); this.#end(turn); return { ok: true }; }
|
|
async closeChat(params, context) {
|
|
const chat = await this.#chat(params, context);
|
|
this.#forgetChat(chat); this.chats.delete(chat.handle); return { ok: true };
|
|
}
|
|
#forgetChat(chat) {
|
|
if (chat.activeTurn) this.#end(chat.activeTurn);
|
|
this.scopes.discard(chat.scope.handle, chat.owner);
|
|
try { this.host.releaseAgentChat?.(chat.record.id, chat.owner.runtimeId); } catch {}
|
|
try { void this.getMcpBridge().cleanupScopedMetadata?.(chat.record.id)?.catch(() => {}); } catch {}
|
|
}
|
|
releaseRuntime(runtimeId) {
|
|
for (const [controller, owner] of this.pendingSelections) if (owner.runtimeId === runtimeId) controller.abort();
|
|
for (const turn of this.turns.values()) if (turn.owner.runtimeId === runtimeId) this.#end(turn);
|
|
for (const chat of this.chats.values()) if (chat.owner.runtimeId === runtimeId) this.#forgetChat(chat);
|
|
for (const opening of this.pendingOpens) if (opening.owner.runtimeId === runtimeId) opening.active = false;
|
|
for (const map of [this.backends, this.selections, this.chats, this.turns]) for (const [id, entry] of map) if (entry.owner.runtimeId === runtimeId) map.delete(id);
|
|
this.scopes.releaseRuntime(runtimeId); this.source.releaseRuntime(runtimeId); this.host.releaseRuntime(runtimeId);
|
|
}
|
|
releasePlugin(pluginId) {
|
|
const ids = new Set([...this.source.bindings.values()].filter((owner) => owner.pluginId === pluginId).map((owner) => owner.runtimeId));
|
|
for (const id of ids) this.releaseRuntime(id);
|
|
}
|
|
releaseAll() { for (const id of [...this.source.bindings.keys()]) this.releaseRuntime(id); }
|
|
shutdown() {
|
|
this.releaseAll(); this.closed = true; this.scopes.shutdown(); this.source.shutdown(); this.revocation.dispose(); this.hostInvalidation();
|
|
for (const item of this.registrations) item.dispose(); this.host.shutdown();
|
|
for (const item of this.targetSubscriptions) item.dispose(); this.targetSubscriptions = [];
|
|
}
|
|
}
|
|
|
|
module.exports = { PluginAgentService, PLUGIN_AGENT_FEATURE: FEATURE, PLUGIN_AGENT_CAPABILITIES: CAPABILITIES };
|