@xopcai/xopc 0.0.411 → 0.0.413

package/dist/src/gateway/hono/routes/phone.js

@@ -0,0 +1,445 @@
+import { createLogger } from "../../../utils/logger/index.js";
+import { init_logger } from "../../../utils/logger.js";
+import { MOCK_PHONE_MODEL, PhoneActionSchema, PhoneConfigSchema, PhoneDeviceSchema, PhoneError, PhoneInputSchema, init_contracts } from "../../../phone/contracts.js";
+import { getDefaultAgentId, init_resolve_route } from "../../../routing/resolve-route.js";
+import { getModelRegistry, init_model_registry } from "../../../providers/model-registry.js";
+import { init_providers, isProviderConfiguredSync } from "../../../providers/index.js";
+import { createPhoneModel, phoneModelProfile } from "../../../phone/model-adapter.js";
+import { getPhoneRuntime, phoneExecutionContext } from "../../../phone/runtime.js";
+import { getGatewayPrincipal } from "../../security/gateway-principal.js";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+//#region src/gateway/hono/routes/phone.ts
+init_resolve_route();
+init_model_registry();
+init_providers();
+init_contracts();
+init_logger();
+const log = createLogger("Hono:Phone");
+const deviceInput = PhoneDeviceSchema.omit({
+	id: true,
+	createdAt: true,
+	revision: true,
+	connection: true
+});
+function registerPhoneRoutes(parent, deps, runtime = getPhoneRuntime()) {
+	const app = new Hono();
+	app.onError((error, c) => {
+		const code = error instanceof PhoneError ? error.code : error instanceof z.ZodError ? "PHONE_INVALID_INPUT" : "PHONE_OPERATION_FAILED";
+		if (!(error instanceof PhoneError) && !(error instanceof z.ZodError)) log.warn({
+			phase: "phone_route",
+			errorCode: code
+		}, "Phone operation failed");
+		return c.json({
+			ok: false,
+			error: {
+				code,
+				message: error instanceof PhoneError ? error.message : error instanceof z.ZodError ? "Invalid phone request" : "Phone operation failed. Check device diagnostics."
+			}
+		}, error instanceof PhoneError ? error.status : error instanceof z.ZodError ? 400 : 500);
+	});
+	const { service, strictRateLimitMiddleware } = deps;
+	app.use("/api/phone/*", async (c, next) => {
+		const principal = getGatewayPrincipal(c);
+		if (principal.kind !== "owner" && principal.kind !== "trusted-proxy" || !principal.scopes.includes("gateway.admin")) return c.json({
+			ok: false,
+			error: {
+				code: "PHONE_ADMIN_REQUIRED",
+				message: "Phone settings require Gateway administrator access"
+			}
+		}, 403);
+		return next();
+	});
+	app.use("/api/phone/cloud/aliyun/*", bodyLimit({
+		maxSize: 24 * 1024,
+		onError: (c) => c.json({
+			ok: false,
+			error: {
+				code: "PHONE_UPLOAD_TOO_LARGE",
+				message: "Phone key upload exceeds 24 KB"
+			}
+		}, 413)
+	}));
+	app.post("/api/phone/cloud/aliyun/test", strictRateLimitMiddleware, async (c) => {
+		const input = z.object({
+			endpoint: z.string().max(200),
+			privateKey: z.string().max(16384)
+		}).strict().parse(await c.req.json());
+		const payload = await runtime.cloud.test(getGatewayPrincipal(c).principalId, input.endpoint, input.privateKey, c.req.raw.signal);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload
+		});
+	});
+	app.post("/api/phone/cloud/aliyun/add", strictRateLimitMiddleware, async (c) => {
+		const input = z.object({
+			token: z.string().uuid(),
+			name: z.string().trim().min(1).max(100),
+			makeDefault: z.boolean().default(false)
+		}).strict().parse(await c.req.json());
+		const payload = await runtime.cloud.add(getGatewayPrincipal(c).principalId, input.token, input.name, input.makeDefault);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload
+		}, 201);
+	});
+	app.delete("/api/phone/cloud/aliyun/tests/:token", (c) => {
+		runtime.cloud.cancel(getGatewayPrincipal(c).principalId, z.string().uuid().parse(c.req.param("token")));
+		return c.json({ ok: true });
+	});
+	app.get("/api/phone/settings", (c) => c.json({
+		ok: true,
+		payload: {
+			config: service.currentConfig.phone,
+			defaultDeviceId: runtime.repository.defaultDevice(),
+			runner: "gateway-local",
+			agentId: getDefaultAgentId()
+		}
+	}));
+	app.patch("/api/phone/settings", strictRateLimitMiddleware, async (c) => {
+		const config = PhoneConfigSchema.parse(await c.req.json());
+		await runtime.shutdown();
+		const next = structuredClone(service.currentConfig);
+		next.phone = config;
+		if (!(await service.saveConfig(next)).saved) throw new PhoneError("PHONE_CONFIG_SAVE_FAILED", "Unable to save Phone Use settings");
+		return c.json({
+			ok: true,
+			payload: { config }
+		});
+	});
+	app.get("/api/phone/devices", async (c) => {
+		let discovery = [];
+		let diagnostic;
+		try {
+			discovery = await runtime.discover(service.currentConfig, c.req.raw.signal);
+		} catch (error) {
+			diagnostic = error instanceof PhoneError ? error.code : "PHONE_ADB_UNAVAILABLE";
+		}
+		return c.json({
+			ok: true,
+			payload: {
+				devices: runtime.repository.list(),
+				discovery,
+				diagnostic,
+				defaultDeviceId: runtime.repository.defaultDevice()
+			}
+		});
+	});
+	app.post("/api/phone/devices", strictRateLimitMiddleware, async (c) => {
+		const input = deviceInput.parse(await c.req.json());
+		if (!(await runtime.discover(service.currentConfig, c.req.raw.signal)).some((device) => device.serial === input.serial && device.state === "device")) throw new PhoneError("PHONE_DEVICE_OFFLINE", "Choose a connected and authorized ADB device");
+		const device = runtime.repository.save(input);
+		if (!runtime.repository.defaultDevice()) runtime.repository.setDefault(device.id);
+		return c.json({
+			ok: true,
+			payload: device
+		}, 201);
+	});
+	app.patch("/api/phone/devices/:id", strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		const previous = runtime.repository.get(id);
+		const patch = deviceInput.omit({ serial: true }).partial().parse(await c.req.json());
+		await runtime.stopDevice(id);
+		return c.json({
+			ok: true,
+			payload: runtime.repository.save({
+				...previous,
+				...patch
+			}, id)
+		});
+	});
+	app.delete("/api/phone/devices/:id", strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		const device = runtime.repository.get(id);
+		await runtime.stopDevice(id);
+		await runtime.cloud.remove(device);
+		runtime.repository.remove(id);
+		return c.json({ ok: true });
+	});
+	app.post("/api/phone/devices/:id/default", strictRateLimitMiddleware, (c) => {
+		runtime.repository.setDefault(c.req.param("id"));
+		return c.json({ ok: true });
+	});
+	app.post("/api/phone/devices/:id/diagnostics", strictRateLimitMiddleware, async (c) => {
+		const device = runtime.repository.get(c.req.param("id"));
+		const found = (await (await runtime.driverFor(device, service.currentConfig)).discover(c.req.raw.signal)).find((item) => item.serial === device.serial);
+		return c.json({
+			ok: true,
+			payload: {
+				state: found?.state ?? "disconnected",
+				emulator: found?.emulator ?? false,
+				runner: "gateway-local",
+				allowedApps: device.allowedApps
+			}
+		});
+	});
+	app.get("/api/phone/devices/:id/screen", async (c) => {
+		const observation = await runtime.preview(c.req.param("id"), service.currentConfig, c.req.raw.signal);
+		const bytes = Uint8Array.from(observation.frame);
+		observation.frame.fill(0);
+		c.header("Cache-Control", "no-store");
+		c.header("Content-Type", "image/png");
+		c.header("X-Content-Type-Options", "nosniff");
+		return c.body(bytes);
+	});
+	app.get("/api/phone/models", (c) => c.json({
+		ok: true,
+		payload: { models: [{
+			id: MOCK_PHONE_MODEL,
+			name: "Mock · Android Settings test",
+			profile: "mock-settings-about",
+			mock: true,
+			configured: true
+		}, ...getModelRegistry().getAll().flatMap((model) => {
+			const profile = phoneModelProfile(model);
+			return profile ? [{
+				id: `${model.provider}/${model.id}`,
+				name: model.name,
+				profile,
+				mock: false,
+				configured: isProviderConfiguredSync(model.provider)
+			}] : [];
+		})] }
+	}));
+	app.post("/api/phone/models/diagnostics", strictRateLimitMiddleware, async (c) => {
+		const body = z.object({
+			modelRef: z.string().min(1),
+			agentId: z.string().optional()
+		}).strict().parse(await c.req.json());
+		const adapter = await createPhoneModel(body.modelRef, service.currentConfig, body.agentId ?? getDefaultAgentId());
+		const { default: sharp } = await import("sharp");
+		const frame = await sharp(Buffer.from("<svg width=\"600\" height=\"1000\" xmlns=\"http://www.w3.org/2000/svg\"><rect width=\"600\" height=\"1000\" fill=\"white\"/><text x=\"60\" y=\"100\" font-size=\"26\">Phone Use connection test</text><rect x=\"100\" y=\"400\" width=\"400\" height=\"160\" fill=\"#2563eb\"/><text x=\"200\" y=\"495\" font-size=\"36\" fill=\"white\">Continue</text></svg>")).png().toBuffer();
+		try {
+			const decision = await adapter.predict({
+				goal: "Tap the blue Continue button. This is a synthetic test image; no phone action will be executed.",
+				allowedApps: ["com.android.settings"],
+				history: [],
+				scenario: body.modelRef === "phone-mock/settings-about" ? "settings-about" : void 0,
+				observation: {
+					frameId: randomUUID(),
+					capturedAt: Date.now(),
+					width: 600,
+					height: 1e3,
+					rotation: 0,
+					package: "com.android.settings",
+					frame,
+					elements: []
+				}
+			}, c.req.raw.signal);
+			const grounded = decision.kind === "action" && decision.action.type === "tap" && decision.action.point[0] >= 167 && decision.action.point[0] <= 833 && decision.action.point[1] >= 400 && decision.action.point[1] <= 560;
+			return c.json({
+				ok: true,
+				payload: {
+					protocolValid: true,
+					groundingVerified: grounded,
+					mock: body.modelRef === MOCK_PHONE_MODEL,
+					deviceActions: 0
+				}
+			});
+		} finally {
+			frame.fill(0);
+		}
+	});
+	const liveClient = z.string().uuid();
+	const liveControlInput = z.object({
+		clientId: liveClient,
+		operationId: z.string().uuid(),
+		epoch: z.number().int().positive(),
+		op: z.enum([
+			"takeover",
+			"release",
+			"handback",
+			"pause",
+			"cancel",
+			"heartbeat",
+			"input",
+			"recover"
+		]),
+		frameSeq: z.number().int().positive().optional(),
+		geometry: z.number().int().positive().optional(),
+		action: PhoneActionSchema.optional()
+	}).strict();
+	async function conversationPhone(conversationId, requestedSessionId) {
+		z.string().uuid().parse(conversationId);
+		const conversation = await service.sessions.getSession(conversationId);
+		if (!conversation) throw new PhoneError("PHONE_CONVERSATION_NOT_FOUND", "Conversation not found", 404);
+		const report = runtime.status(conversationId);
+		if (requestedSessionId && report?.sessionId !== requestedSessionId) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		if (report && report.agentId !== conversation.agentId) throw new PhoneError("PHONE_ACCESS_CHANGED", "Conversation Agent changed", 403);
+		return {
+			report,
+			transcriptId: conversation.transcriptId,
+			context: phoneExecutionContext(service.currentConfig, conversation.agentId)
+		};
+	}
+	app.get("/api/phone/conversations/:conversationId", async (c) => {
+		const owner = c.req.param("conversationId");
+		const client = liveClient.parse(c.req.query("clientId"));
+		const { report, context } = await conversationPhone(owner);
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: report ? runtime.liveStatus(owner, report.sessionId, context, `${getGatewayPrincipal(c).principalId}:${client}`) : null
+		});
+	});
+	app.get("/api/phone/conversations/:conversationId/:sessionId/frame", async (c) => {
+		const owner = c.req.param("conversationId");
+		const id = c.req.param("sessionId");
+		const { context } = await conversationPhone(owner, id);
+		const frame = await runtime.liveFrame(owner, id, context, c.req.raw.signal);
+		c.header("Cache-Control", "no-store");
+		c.header("Content-Type", "image/png");
+		c.header("X-Content-Type-Options", "nosniff");
+		c.header("X-Phone-Frame-Seq", String(frame.seq));
+		c.header("X-Phone-Captured-At", String(frame.capturedAt));
+		c.header("X-Phone-Width", String(frame.width));
+		c.header("X-Phone-Height", String(frame.height));
+		c.header("X-Phone-Rotation", String(frame.rotation));
+		const bytes = Uint8Array.from(frame.frame);
+		frame.frame.fill(0);
+		return c.body(bytes);
+	});
+	app.post("/api/phone/conversations/:conversationId/:sessionId/video-ticket", strictRateLimitMiddleware, async (c) => {
+		const owner = c.req.param("conversationId");
+		const id = c.req.param("sessionId");
+		const { clientId } = z.object({ clientId: liveClient }).strict().parse(await c.req.json());
+		await conversationPhone(owner, id);
+		const principal = getGatewayPrincipal(c);
+		const client = `${principal.principalId}:${clientId}`;
+		const validate = async () => {
+			const { context } = await conversationPhone(owner, id);
+			runtime.liveStatus(owner, id, context, client);
+		};
+		const issued = service.phoneStreams.issue({
+			origin: new URL(c.req.url).origin,
+			principal: principal.principalId,
+			client,
+			validate,
+			connect: async () => {
+				const { context } = await conversationPhone(owner, id);
+				return runtime.liveVideo(owner, id, context);
+			},
+			disconnect: () => runtime.disconnectVideo(owner, id, client)
+		});
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: {
+				...issued,
+				transport: "scrcpy-h264",
+				protocolVersion: 1
+			}
+		});
+	});
+	app.post("/api/phone/conversations/:conversationId/:sessionId/control", async (c) => {
+		const owner = c.req.param("conversationId");
+		const id = c.req.param("sessionId");
+		const { context, transcriptId } = await conversationPhone(owner, id);
+		const { clientId, ...input } = liveControlInput.parse(await c.req.json());
+		const result = await runtime.liveControl(owner, id, context, `${getGatewayPrincipal(c).principalId}:${clientId}`, input);
+		if (input.op === "handback" && result.resumeTurnRequired && !service.sessions.getActiveRun(owner).active) {
+			if (!(await service.submitSessionInput({
+				conversationId: owner,
+				expectedTranscriptId: transcriptId,
+				clientMessageId: input.operationId,
+				delivery: "next",
+				content: "手机已交还，请先确认当前页面，继续未完成的任务；已完成的步骤不要重复，结束后关闭手机会话。",
+				origin: {
+					type: "system",
+					source: "internal"
+				}
+			})).ok) throw new PhoneError("PHONE_RESUME_FAILED", "Phone control returned. Send Continue in chat to resume the task.", 409);
+		}
+		c.header("Cache-Control", "no-store");
+		return c.json({
+			ok: true,
+			payload: result
+		});
+	});
+	const ownerFor = (principalId, id) => `phone-settings:${principalId}:${id}`;
+	app.get("/api/phone/sessions", (c) => c.json({
+		ok: true,
+		payload: {
+			sessions: runtime.reports(),
+			history: runtime.repository.history()
+		}
+	}));
+	app.post("/api/phone/sessions", strictRateLimitMiddleware, async (c) => {
+		const body = z.object({
+			deviceId: z.string().uuid().optional(),
+			agentId: z.string().optional(),
+			mode: z.enum(["observe", "control"]),
+			appPackage: z.string().optional()
+		}).strict().parse(await c.req.json());
+		const id = randomUUID();
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, id);
+		const { agentId = getDefaultAgentId(), ...input } = body;
+		const report = await runtime.execute(owner, {
+			op: "open",
+			...input
+		}, phoneExecutionContext(service.currentConfig, agentId), c.req.raw.signal);
+		return c.json({
+			ok: true,
+			payload: {
+				id,
+				report
+			}
+		}, 201);
+	});
+	app.get("/api/phone/sessions/:id", (c) => {
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, c.req.param("id"));
+		const report = runtime.status(owner);
+		if (!report) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		return c.json({
+			ok: true,
+			payload: report
+		});
+	});
+	app.get("/api/phone/sessions/:id/screen", async (c) => {
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, c.req.param("id"));
+		const report = runtime.status(owner);
+		if (!report) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		const observation = await runtime.previewSession(owner, phoneExecutionContext(service.currentConfig, report.agentId), c.req.raw.signal);
+		const bytes = Uint8Array.from(observation.frame);
+		observation.frame.fill(0);
+		c.header("Cache-Control", "no-store");
+		c.header("Content-Type", "image/png");
+		c.header("X-Content-Type-Options", "nosniff");
+		return c.body(bytes);
+	});
+	app.post("/api/phone/sessions/:id/execute", strictRateLimitMiddleware, async (c) => {
+		const owner = ownerFor(getGatewayPrincipal(c).principalId, c.req.param("id"));
+		const report = runtime.status(owner);
+		if (!report) throw new PhoneError("PHONE_SESSION_NOT_FOUND", "Phone session not found", 404);
+		const input = PhoneInputSchema.parse(await c.req.json());
+		if (["open", "discover"].includes(input.op)) throw new PhoneError("PHONE_INVALID_OPERATION", "Use the phone discovery and session creation endpoints");
+		const operation = runtime.execute(owner, input, phoneExecutionContext(service.currentConfig, report.agentId));
+		if (input.op === "run" || input.op === "step") {
+			let immediateError;
+			operation.catch((error) => {
+				immediateError = error;
+				log.info({
+					sessionId: report.sessionId,
+					errorCode: error instanceof PhoneError ? error.code : "PHONE_OPERATION_FAILED"
+				}, "Phone execution stopped");
+			});
+			await Promise.resolve();
+			if (immediateError) throw immediateError;
+			return c.json({
+				ok: true,
+				payload: runtime.status(owner)
+			}, 202);
+		}
+		return c.json({
+			ok: true,
+			payload: await operation
+		});
+	});
+	parent.route("/", app);
+}
+//#endregion
+export { registerPhoneRoutes };

package/dist/src/gateway/hono/routes/projects.js

@@ -6,12 +6,12 @@ import { loadTranscriptRowsForSession } from "../../../storage/sqlite/transcript
 import { init_sqlite } from "../../../storage/sqlite/index.js";
 import { ActivityService } from "../../../activity/service.js";
 import "../../../activity/index.js";
-import { CapabilityError } from "../../../capabilities/runtime/errors.js";
-import "../../../capabilities/runtime/dispatcher.js";
 import { listKnowledgeItems, writeKnowledgeItem } from "../../../knowledge-memory/repository.js";
 import "../../../knowledge-memory/index.js";
 import { resolveEffectiveAgentProfile } from "../../../config/agent-profile.js";
 import { TaskReadModelProjector } from "../../../tasks/task-read-model-projector.js";
+import { CapabilityError } from "../../../capabilities/runtime/errors.js";
+import "../../../capabilities/runtime/dispatcher.js";
 import { ProjectWorkspaceConflictError, ProjectWorkspaceMissingError } from "../../../projects/workspace-project.js";
 import { inferProjectExecutionMode, inferProjectKind } from "../../../projects/project-kind.js";
 import { ProjectDeletionBlockedError, ProjectWorkspaceInUseError } from "../../../projects/project-service.js";

package/dist/src/gateway/hono/routes/runtime-tools.js

@@ -4,6 +4,7 @@ import { normalizeRuntimeVersionRequest } from "../../../runtime-tools/probe.js"
 import { ManagedRuntimeManager } from "../../../runtime-tools/manager.js";
 import { createGatewayRouteLogger } from "../lib/route-logger.js";
 import { pruneRuntimeTools } from "../../../runtime-tools/prune.js";
+import { registerPhoneDependencyRoutes } from "./phone-dependencies.js";
 import { streamSSE } from "hono/streaming";
 //#region src/gateway/hono/routes/runtime-tools.ts
 init_paths_state();
@@ -32,6 +33,7 @@ async function readJson(c) {
 }
 function registerRuntimeToolsRoutes(authenticated, deps) {
 	const { service, strictRateLimitMiddleware } = deps;
+	registerPhoneDependencyRoutes(authenticated, deps);
 	authenticated.get("/api/runtime-tools", async (c) => {
 		const statuses = await runtimeManager(service.currentConfig).statusAll();
 		return c.json({

package/dist/src/gateway/hono/routes/session-input-handler.js

@@ -5,9 +5,9 @@ import { endpointContextSchema } from "../../../../packages/gateway-contract/src
 import { parseUserTurnDocument, userTurnDocumentRefIds } from "../../../../packages/gateway-contract/src/user-turn-document.js";
 import { init_src } from "../../../../packages/gateway-contract/src/index.js";
 import { endpointTurnClaimSchema, init_src as init_src$1 } from "../../../../packages/endpoint-tools-protocol/src/index.js";
+import { init_providers, resolveModel } from "../../../providers/index.js";
 import { CapabilityError } from "../../../capabilities/runtime/errors.js";
 import "../../../capabilities/runtime/dispatcher.js";
-import { init_providers, resolveModel } from "../../../providers/index.js";
 import { getModelThinking } from "../../../providers/model-thinking.js";
 import { parseTurnContextRefs } from "../../../agent/source-context/types.js";
 import { validateWebchatAttachments, validateWebchatContent } from "../../chat-limits.js";

package/dist/src/gateway/hono/routes/tasks.js

@@ -6,9 +6,9 @@ import { hasGatewayScope, init_gateway_scopes } from "../../security/gateway-sco
 import { enqueueTaskChangedEvent, init_task_change_events } from "../../../tasks/task-change-events.js";
 import { TaskRepository, init_task_repository } from "../../../tasks/task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../../../tasks/task-run-repository.js";
+import { TaskConversationRepository } from "../../../tasks/task-conversation-repository.js";
 import { CapabilityError } from "../../../capabilities/runtime/errors.js";
 import "../../../capabilities/runtime/dispatcher.js";
-import { TaskConversationRepository } from "../../../tasks/task-conversation-repository.js";
 import { TaskCollaborationRepository } from "../../../tasks/task-collaboration-repository.js";
 import { TaskCriterionReviewRepository } from "../../../tasks/task-criterion-review-repository.js";
 import { TaskContextMutationOutputSchema } from "../../../tasks/capabilities/relations.js";

package/dist/src/gateway/image-generation-setup.js

@@ -1,11 +1,11 @@
 import { normalizeAgentId } from "../agent-catalog/id.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
 import { init_agent_scope } from "../agent/agent-scope.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
 import { resolveEffectiveAgentConfigForAgent } from "../config/agent-profile.js";
 import { fetchWithTimeoutGuarded } from "../media-shared/http/provider-http.js";
 import "../media-shared/http/index.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getImageGenerationProvider, listImageGenerationProvidersSummary } from "../agent/image/generation/provider-registry.js";
 //#region src/gateway/image-generation-setup.ts
 init_repository();

package/dist/src/gateway/server.js

@@ -69,6 +69,7 @@ var GatewayServer = class {
 			inner.on("upgrade", (req, socket, head) => {
 				try {
 					if (this.service.voiceRealtime.handleUpgrade(req, socket, head)) return;
+					if (this.service.phoneStreams.handleUpgrade(req, socket, head)) return;
 					if (this.service.realtime.handleUpgrade(req, socket, head)) return;
 					if (handleSiteShareUpgrade(this.service, req, socket, head)) return;
 					socket.destroy();

package/dist/src/gateway/service/config-coordinator.d.ts

@@ -323,6 +323,14 @@ export declare class GatewayConfigCoordinator {
             maxSessionDurationMs: number;
             idleGrantTtlMs: number;
         };
+        phone: {
+            enabled: boolean;
+            maxActionsPerSession: number;
+            maxModelRequests: number;
+            maxOperationDurationMs: number;
+            maxSessionDurationMs: number;
+            adbPath?: string;
+        };
         tools: {
             web?: {
                 region?: "global" | "cn";

package/dist/src/gateway/service.d.ts

@@ -1,4 +1,5 @@
 import type { ClarificationSubmission } from '@xopcai/gateway-contract';
+import { PhoneStreamGateway } from '../phone/stream-gateway.js';
 import { WorkDiscoveryService } from '../work-discovery/service.js';
 import { ConnectionRecoveryService } from '../connectors/connection-recovery-service.js';
 import { AgentService } from '../agent/service.js';
@@ -55,6 +56,7 @@ export declare class GatewayService {
     readonly endpointTools: EndpointToolRuntime;
     private isRealtimePrincipalActive;
     readonly realtime: RealtimeRuntime;
+    readonly phoneStreams: PhoneStreamGateway;
     readonly voiceRealtime: VoiceRealtimeRuntime;
     getConfig(): Config;
     getModelCatalogSync(): ModelCatalogSyncService;

package/dist/src/gateway/service.js

@@ -32,8 +32,8 @@ import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.
 import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { init_providers, providers_exports } from "../providers/index.js";
-import { flushTracing } from "../observability/runtime.js";
 import { AI_USAGE_RETENTION_MS, markStaleAiUsageEventsUnknown, pruneAiUsageEvents } from "../storage/sqlite/ai-usage-repository.js";
+import { flushTracing } from "../observability/runtime.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import { getPersonalAgentByConversation } from "../personal-agent/repository.js";
 import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
@@ -87,13 +87,6 @@ import { ChatPreviewService } from "../chat-previews/service.js";
 import "../chat-previews/index.js";
 import { configureGatewayHttpProxy } from "../infra/http-proxy-env.js";
 import "../config/index.js";
-import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
-import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
-import "../knowledge/index.js";
-import { PersonalReplyComposer } from "../personal-agent/reply-composer.js";
-import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
-import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
-import { startConnectorSupervisor } from "../connectors/supervisor.js";
 import { DiscussionService } from "../discussions/service.js";
 import { DiscussionOrganizer } from "../discussions/organizer.js";
 import { DiscussionLiveWorker } from "../discussions/live-worker.js";
@@ -102,11 +95,23 @@ import { DiscussionSealer } from "../discussions/sealer.js";
 import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
+import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
+import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
+import "../knowledge/index.js";
+import { PersonalReplyComposer } from "../personal-agent/reply-composer.js";
+import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
+import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
+import { startConnectorSupervisor } from "../connectors/supervisor.js";
+import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
+import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
+import { HomeIntelligenceHost } from "../home-intelligence/host.js";
+import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { getGatewayFileSpaceService } from "./file-space-service.js";
 import { reconcileHomeIntelligenceAutomation } from "./home-intelligence-automation-reconciler.js";
+import { PhoneStreamGateway } from "../phone/stream-gateway.js";
 import { PersonalProactivityService } from "../personal-agent/proactivity/service.js";
 import { reconcilePersonalProactivityAutomation } from "../personal-agent/proactivity/automation.js";
 import { createBackgroundTask } from "../infra/background-task.js";
@@ -159,10 +164,6 @@ import { TaskMainUpdateDecisionService } from "../tasks/task-main-update-decisio
 import { selectTaskMainUpdateAttempt, submitAndConfirmTaskMainUpdate } from "../tasks/task-main-update-input.js";
 import { checkAppContextAccess, prepareAppContext } from "./service/app-context-access.js";
 import { applyAutomaticVoiceLanguage, inferProductLanguageFromEnvironment, initializeVoiceDefaults } from "../voice/language-profile.js";
-import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
-import { HomeIntelligenceHost } from "../home-intelligence/host.js";
-import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
-import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
 import crypto from "node:crypto";
 //#region src/gateway/service.ts
 init_session_repository();
@@ -220,6 +221,7 @@ var GatewayService = class {
 		}
 	};
 	realtime = new RealtimeRuntime(this.endpointTools, this.isRealtimePrincipalActive);
+	phoneStreams = new PhoneStreamGateway(this.isRealtimePrincipalActive);
 	voiceRealtime = new VoiceRealtimeRuntime({
 		isPrincipalActive: this.isRealtimePrincipalActive,
 		getConversationContext: async (conversationId, expectedTranscriptId) => {
@@ -1565,6 +1567,9 @@ var GatewayService = class {
 		await flushTracing();
 		if (!this.running) return;
 		this.stopping = true;
+		const { getPhoneRuntime } = await import("../phone/runtime.js");
+		await getPhoneRuntime().shutdown();
+		this.phoneStreams.close();
 		const { cancelAllPluginCliAuthorizations } = await import("../extensions/agent-plugins/cli-authorization.js");
 		cancelAllPluginCliAuthorizations();
 		this.taskAllocationDispatcher?.stop();

package/dist/src/gateway/xopc-cloud-capability-setup.js

@@ -1,13 +1,13 @@
 import "../agent-config/schema.js";
 import { init_agent_config } from "../agent-config/index.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
 import { init_model_policy, isComputerModel, isDedicatedComputerProfile } from "../computer/model-policy.js";
 import { voiceSupportsMode } from "../../packages/realtime-protocol/src/voice-catalog.js";
 import { init_voice } from "../../packages/realtime-protocol/src/voice.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
 init_voice();

package/dist/src/home-intelligence/host.js

@@ -1,10 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { HomeAdviceBudgetExceededError, isHomeProseLocalized } from "./generator.js";
 import { homePatternKey } from "./strategy.js";
-import { HomeAdvicePolicy } from "./policy.js";
 import { HomeIntelligenceRepository } from "./repository.js";
 import { HomeOpportunityApplicationService } from "./application-service.js";
+import { HomeAdvicePolicy } from "./policy.js";
+import { HomeAdviceBudgetExceededError, isHomeProseLocalized } from "./generator.js";
 import { buildHomeOpportunityNotification } from "./notification.js";
 import { createHash } from "node:crypto";
 //#region src/home-intelligence/host.ts