wtagent 0.4.0 → 1.0.0

package/src/session/agent-session.js

@@ -115,7 +115,10 @@ async function acquirePersistenceLockMutex(
         try {
           servers.push(await openPersistenceLockServer({ port, token }));
         } catch (error) {
-          if (error.code !== "EADDRINUSE") {
+          // Windows excluded port ranges fail with EACCES rather than
+          // EADDRINUSE. Both make this member unavailable; the same fixed
+          // majority is still required, so contenders cannot bypass the lock.
+          if (error.code !== "EADDRINUSE" && error.code !== "EACCES") {
             throw error;
           }
           lastError = error;
@@ -560,7 +563,7 @@ export class AgentSession {
     this.persistenceQueue = Promise.resolve();
   }
 
-  static async create({ sessionsDir, tasksDir, task, projectRoot, mode, provider = "chatgpt" }) {
+  static async create({ sessionsDir, tasksDir, task, projectRoot, mode, provider = "chatgpt", generationType = "agent" }) {
     const root = await ensureSessionsRoot(sessionsDir ?? tasksDir);
     const sessionId = `session_${new Date().toISOString().replaceAll(/[-:.TZ]/g, "").slice(0, 14)}_${randomUUID().slice(0, 8)}`;
     const directory = path.join(root, sessionId);
@@ -574,6 +577,7 @@ export class AgentSession {
       projectRoot: path.resolve(projectRoot),
       provider,
       mode,
+      generationType,
       phase: "idle",
       turn: 0,
       runCount: 0,
@@ -583,6 +587,7 @@ export class AgentSession {
       lastAssistantMessageId: null,
       pendingOutbound: null,
       pendingAssistantTurn: null,
+      pendingAuxiliaryTurn: null,
       activeMode: null,
       stateRevision: 0,
       createdAt: now,
@@ -657,6 +662,7 @@ export class AgentSession {
     state.lastAssistantMessageId ??= null;
     state.pendingOutbound ??= null;
     state.pendingAssistantTurn ??= null;
+    state.pendingAuxiliaryTurn ??= null;
     state.activeMode ??= null;
     state.stateRevision = stateRevision(state);
     state.rolloutFile ??= "transcript.jsonl";
@@ -1130,6 +1136,63 @@ export class AgentSession {
     });
   }
 
+  async commitPendingAuxiliaryTurn({ outboundId, turn = {} }) {
+    if (typeof outboundId !== "string" || outboundId.length === 0) {
+      throw new Error("A pending outbound ID is required for an auxiliary turn.");
+    }
+    return await this.#mutateState((nextState) => {
+      if (nextState.pendingOutbound?.outboundId !== outboundId) {
+        throw new Error(`Pending outbound changed before auxiliary turn: ${outboundId}`);
+      }
+      const now = new Date().toISOString();
+      const pending = {
+        version: 1,
+        outboundId,
+        status: "waiting",
+        conversationUrl: turn.conversationUrl
+          ?? nextState.conversationUrl
+          ?? null,
+        conversationTargetId: turn.conversationTargetId
+          ?? nextState.conversationTargetId
+          ?? null,
+        userMessageId: turn.userMessageId ?? null,
+        userTurn: turn.userTurn ?? null,
+        assistantBaseline: turn.assistantBaseline ?? null,
+        createdAt: now,
+        updatedAt: now,
+      };
+      nextState.pendingOutbound = null;
+      nextState.pendingAuxiliaryTurn = pending;
+      nextState.conversationUrl = pending.conversationUrl;
+      nextState.conversationTargetId = pending.conversationTargetId;
+      nextState.lastUserMessageId = pending.userMessageId;
+      nextState.updatedAt = now;
+      return structuredClone(pending);
+    });
+  }
+
+  async completePendingAuxiliaryTurn({
+    outboundId,
+    assistantMessageId = null,
+    assistantTurn = null,
+  }) {
+    return await this.#mutateState((nextState) => {
+      const current = nextState.pendingAuxiliaryTurn;
+      if (!current || current.outboundId !== outboundId) {
+        throw new Error(`Pending auxiliary turn changed before completion: ${outboundId}`);
+      }
+      nextState.lastAssistantMessageId = assistantMessageId;
+      nextState.pendingAuxiliaryTurn = null;
+      nextState.updatedAt = new Date().toISOString();
+      return {
+        ...structuredClone(current),
+        status: "complete",
+        assistantMessageId,
+        assistantTurn,
+      };
+    });
+  }
+
   async refreshPendingAssistantTurn(handoffId, patch = {}) {
     const requested = structuredClone(patch);
     const protectedKeys = new Set([
@@ -1142,6 +1205,8 @@ export class AgentSession {
       "createdAt",
       "rawResponse",
       "responseHash",
+      "nativeImages",
+      "nativeMusic",
     ]);
     if (Object.keys(requested).some((key) => protectedKeys.has(key))) {
       throw new Error("Assistant handoff refresh contains protected fields.");
@@ -1184,6 +1249,8 @@ export class AgentSession {
     assistantMessageId = null,
     assistantTurn = null,
     rawResponse,
+    nativeImages = [],
+    nativeMusic = [],
     completedAt = new Date().toISOString(),
   }) {
     if (typeof rawResponse !== "string") {
@@ -1197,6 +1264,8 @@ export class AgentSession {
       assistantTurn,
       rawResponse,
       responseHash,
+      nativeImages: structuredClone(nativeImages),
+      nativeMusic: structuredClone(nativeMusic),
     };
     return await this.#mutateState((nextState) => {
       const current = nextState.pendingAssistantTurn;
@@ -1211,6 +1280,8 @@ export class AgentSession {
           assistantTurn: current.assistantTurn ?? null,
           rawResponse: current.rawResponse,
           responseHash: current.responseHash,
+          nativeImages: current.nativeImages ?? [],
+          nativeMusic: current.nativeMusic ?? [],
         };
         if (!isDeepStrictEqual(existing, completion)) {
           throw new Error(

package/src/tools/image-tools.js

@@ -0,0 +1,92 @@
+import path from "node:path";
+import { z } from "zod";
+import { resolveToolPath } from "../policy/path-guard.js";
+
+const xmlStringArray = z.preprocess((value) => {
+  if (value == null || value === "") return [];
+  if (Array.isArray(value)) return value;
+  if (typeof value === "object" && value.item != null) {
+    return Array.isArray(value.item) ? value.item : [value.item];
+  }
+  if (typeof value === "string" && value.trim().startsWith("[")) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+      // Treat malformed JSON-looking input as one path; Zod will validate it.
+    }
+  }
+  return [value];
+}, z.array(z.string().min(1)));
+
+export const imageGenerateInputSchema = z.object({
+  prompt: z.string().min(1),
+  output_path: z.string().min(1),
+  provider: z.enum(["auto", "chatgpt", "gemini", "grok"]).default("auto"),
+  aspect_ratio: z.enum(["auto", "1:1", "3:2", "2:3", "4:3", "3:4", "16:9", "9:16"])
+    .default("auto"),
+  reference_images: xmlStringArray.default([]),
+  timeout_ms: z.coerce.number().int().min(30_000).max(30 * 60_000)
+    .default(10 * 60_000),
+});
+
+export function registerImageTools(registry, { imageService }) {
+  if (!imageService) return registry;
+  registry.register({
+    name: "image.generate",
+    description: [
+      "Generate one raster image through a supported web provider and download it to the local project.",
+      "The operation succeeds only after a verified PNG, JPEG, or WebP artifact is atomically saved.",
+      "If the provider finishes with text instead of an image, its reply is returned as a failed image result; read that reply before deciding the next step.",
+      "Use provider=auto to use this session's provider when image-capable, otherwise ChatGPT;",
+      "or choose chatgpt, gemini, or grok explicitly.",
+      "Prefer aspect_ratio=auto. Unsupported ratios fall back to auto instead of failing.",
+    ].join(" "),
+    inputDescription:
+      "<args><prompt><![CDATA[...]]></prompt><output_path>images/result.png</output_path><provider>auto</provider><aspect_ratio>auto|1:1|3:2|2:3|4:3|3:4|16:9|9:16</aspect_ratio><reference_images><item>references/style.png</item></reference_images><timeout_ms>600000</timeout_ms></args>",
+    risk: "write",
+    managesTimeout: true,
+    requiresVisibleBrowser: true,
+    inputSchema: imageGenerateInputSchema,
+    execute: async (args, context) => {
+      const referenceImages = [];
+      for (const rawPath of args.reference_images) {
+        const info = await resolveToolPath(context.projectRoot, rawPath);
+        if (!info.inside && !context.allowOutside) {
+          throw new Error(`Path is outside project root: ${info.path}`);
+        }
+        referenceImages.push(info.path);
+      }
+      const artifact = await imageService.generate({
+        prompt: args.prompt,
+        outputPath: args.output_path,
+        provider: args.provider,
+        aspectRatio: args.aspect_ratio,
+        referenceImages,
+        timeoutMs: args.timeout_ms,
+      }, context);
+      if (artifact.type === "text") {
+        return {
+          ok: false,
+          message: `Image provider returned text instead of an image:\n\n${artifact.text}`,
+          data: { response: artifact },
+          meta: { code: "IMAGE_TEXT_RESPONSE", completionUnknown: false },
+        };
+      }
+      const relative = path.relative(context.projectRoot, artifact.localPath);
+      const location = relative && !relative.startsWith("..")
+        ? relative
+        : artifact.localPath;
+      let message = `Generated image at ${location}.`;
+      if (artifact.provenance?.requestedAspectRatio) {
+        message += ` Requested aspect_ratio ${artifact.provenance.requestedAspectRatio} is not supported by ${artifact.provenance.provider}; used ${artifact.provenance.aspectRatio}.`;
+      }
+      return {
+        ok: true,
+        message,
+        data: { artifact },
+      };
+    },
+  });
+  return registry;
+}

package/src/tools/registry.js

@@ -114,16 +114,28 @@ export class ToolRegistry {
         meta: result.meta,
       };
     } catch (error) {
+      const meta = {
+        ...(error?.meta ?? {}),
+        ...(error?.code ? {
+          code: error.code,
+          recoverable: error.recoverable ?? false,
+          ...(error.details ? { details: error.details } : {}),
+        } : {}),
+        ...(error?.completionUnknown ? {
+          completionUnknown: true,
+          recoverable: error.recoverable ?? true,
+        } : {}),
+      };
       return {
         callId: preparedCall.id,
         name: preparedCall.name,
         ok: false,
         message: error.message,
         stderr: error.stack,
+        meta: Object.keys(meta).length ? meta : undefined,
       };
     } finally {
       clearTimeout(timer);
     }
   }
 }
-