| import { isRecord } from "@openclaw/normalization-core/record-coerce"; |
| import { createAgentRuntimeIdentity } from "../../gateway/agent-runtime-identity-token.js"; |
| import { |
| parseComputerUseCapabilityDescriptor, |
| type ComputerUseCapabilityDescriptor, |
| } from "../../plugins/computer-use-contract.js"; |
| import { getGatewayToolCallerIdentity } from "./gateway-caller-context.js"; |
| import { |
| callGatewayTool, |
| shouldUseInProcessGatewayTool, |
| type GatewayCallOptions, |
| } from "./gateway.js"; |
|
|
| export type GatewayComputerStatus = |
| | { configured: false; available: false } |
| | { configured: true; available: false; error?: string } |
| | { configured: true; available: true; computerUse: ComputerUseCapabilityDescriptor }; |
|
|
| export async function loadGatewayComputerStatus( |
| options: GatewayCallOptions, |
| signal?: AbortSignal, |
| ): Promise<GatewayComputerStatus> { |
| const result = await callGatewayTool<unknown>("computer.status", options, {}, { signal }); |
| if (!isRecord(result) || typeof result.configured !== "boolean") { |
| throw new Error("COMPUTER_CONTRACT_MISMATCH: invalid Gateway computer status"); |
| } |
| if (!result.configured) { |
| return { configured: false, available: false }; |
| } |
| if (result.available !== true) { |
| return { |
| configured: true, |
| available: false, |
| ...(typeof result.error === "string" ? { error: result.error } : {}), |
| }; |
| } |
| const computerUse = parseComputerUseCapabilityDescriptor(result.computerUse); |
| return { configured: true, available: true, computerUse }; |
| } |
|
|
| |
| export async function bindGatewayComputerCleanup(params: { |
| options: GatewayCallOptions; |
| generation: string; |
| executionId: string; |
| }): Promise<((reason: string) => Promise<unknown>) | undefined> { |
| const caller = getGatewayToolCallerIdentity(); |
| if (!shouldUseInProcessGatewayTool(params.options) || !caller?.operationalRunInstance) { |
| return undefined; |
| } |
| const identity = await createAgentRuntimeIdentity({ |
| ...caller, |
| operationalRunInstance: caller.operationalRunInstance, |
| }); |
| if (!identity) { |
| throw new Error("Gateway computer cleanup requires the admitted run identity"); |
| } |
| const { |
| bindAgentToolGatewayRequest, |
| runWithGatewayToolCleanupContext, |
| withAgentToolGatewayRuntimeIdentity, |
| } = await import("./in-process-gateway.js"); |
| const request = runWithGatewayToolCleanupContext( |
| () => bindAgentToolGatewayRequest({ resolveGatewayContext: caller.gatewayContextResolver }), |
| caller.gatewayContextResolver, |
| ); |
| return async (reason) => { |
| const result = await request<{ payload: unknown }>( |
| withAgentToolGatewayRuntimeIdentity( |
| { |
| method: "computer.invoke", |
| params: { |
| generation: params.generation, |
| command: "computer.act", |
| params: { action: "__close_execution", executionId: params.executionId, reason }, |
| idempotencyKey: `computer.close:${params.executionId}:gateway`, |
| }, |
| timeoutMs: params.options.timeoutMs, |
| }, |
| identity, |
| ), |
| ); |
| return result.payload; |
| }; |
| } |
|
|
