@gravity-rail/cli 0.32.0 → 0.33.1

package/dist/lib.js

@@ -8624,6 +8624,12 @@ var qualificationsDomain = {
           required: false
         },
         { name: "goal", description: "Goal for the user simulator", required: false },
+        { name: "channel", description: "Run channel: web-chat | web-voice", required: false },
+        {
+          name: "anonymous",
+          description: "Use an anonymous caller: true | false; otherwise inherit scenario",
+          required: false
+        },
         { name: "driver", description: "Driver mode: auto | human", required: false },
         {
           name: "workflow-revision-id",
@@ -8656,7 +8662,17 @@ var qualificationsDomain = {
           required: false
         }
       ],
-      handler: async ({ ctx, workspace, args }) => {
+      handler: async ({ ctx, workspace, args, data }) => {
+        if (data !== void 0 || args["data"] !== void 0) {
+          throw new CLIError(
+            "runs start does not accept --data; use --channel, --anonymous and the named run flags"
+          );
+        }
+        const channel = args["channel"];
+        if (channel !== void 0 && channel !== "web-chat" && channel !== "web-voice") {
+          throw new CLIError("--channel must be web-chat or web-voice");
+        }
+        const anonymous = optionalBool(args, "anonymous");
         const driver = args["driver"] === "human" ? DriverMode2.HUMAN : DriverMode2.AUTO;
         const scenarioId = args["scenario-id"] ? requireNumber(args, "scenario-id") : void 0;
         const personaId = args["persona-id"] ? requireNumber(args, "persona-id") : void 0;
@@ -8680,6 +8696,8 @@ var qualificationsDomain = {
             ...args["workflow-revision-id"] ? { workflowRevisionId: requireNumber(args, "workflow-revision-id") } : {},
             ...args["workflow-revision-uuid"] ? { workflowRevisionUuid: String(args["workflow-revision-uuid"]) } : {},
             ...args["goal"] ? { goal: String(args["goal"]) } : {},
+            ...channel !== void 0 ? { channel } : {},
+            ...anonymous !== void 0 ? { anonymous } : {},
             ...args["assistant-chat-model-id"] ? { assistantChatModelId: String(args["assistant-chat-model-id"]) } : {},
             ...args["assistant-realtime-model-id"] ? {
               assistantRealtimeModelId: String(args["assistant-realtime-model-id"])
@@ -10355,12 +10373,81 @@ var ActivityRefResolver = class {
       forWorkspace.set(`${ref.kind}|${ref.uuid}`, ref);
       byWorkspace.set(ref.workspaceUuid, forWorkspace);
     }
+    const groups = [...byWorkspace].map(
+      ([workspaceUuid, wanted]) => [workspaceUuid, [...wanted.values()]]
+    );
+    if (this.options.orgUuid) {
+      await this.primeOrg(this.options.orgUuid, groups);
+      return;
+    }
     await Promise.all(
-      [...byWorkspace].map(
-        ([workspaceUuid, wanted]) => this.primeWorkspace(workspaceUuid, [...wanted.values()])
-      )
+      groups.map(([workspaceUuid, wanted]) => this.primeWorkspace(workspaceUuid, wanted))
     );
   }
+  /**
+   * One org call per chunk, each carrying whole workspace groups.
+   *
+   * The server's cap is over the whole request rather than per workspace, and
+   * it accepts each workspace at most once per request — so a group larger
+   * than the cap is split across requests, and smaller groups ride together
+   * until the next one would not fit.
+   */
+  async primeOrg(orgUuid, groups) {
+    const chunks = [];
+    let current = [];
+    let size = 0;
+    for (const [workspaceUuid, refs] of groups) {
+      for (let start = 0; start < refs.length; start += MAX_REFS_PER_BATCH) {
+        const slice = refs.slice(start, start + MAX_REFS_PER_BATCH);
+        if (size + slice.length > MAX_REFS_PER_BATCH && current.length > 0) {
+          chunks.push(current);
+          current = [];
+          size = 0;
+        }
+        current.push([workspaceUuid, slice]);
+        size += slice.length;
+      }
+    }
+    if (current.length > 0) chunks.push(current);
+    for (const chunk of chunks) {
+      const key = `org:${orgUuid}|${chunk.map(
+        ([workspaceUuid, refs]) => `${workspaceUuid}:${refs.map((ref) => `${ref.kind}|${ref.uuid}`).sort().join(",")}`
+      ).sort().join(";")}`;
+      const pending = this.inFlight.get(key) ?? this.fetchOrgChunk(orgUuid, chunk, key);
+      this.inFlight.set(key, pending);
+      await pending;
+    }
+  }
+  /** One org batch call, seeded into the same per-ref cache. */
+  async fetchOrgChunk(orgUuid, chunk, key) {
+    try {
+      this.fetches += 1;
+      const response = await this.client.resolveOrgEntityRefs(orgUuid, {
+        workspaces: chunk.map(([workspaceUuid, refs]) => ({
+          workspaceUuid,
+          refs: refs.map((ref) => ({ kind: ref.kind, uuid: ref.uuid }))
+        }))
+      });
+      const answered = new Map(
+        response.workspaces.map((group) => [
+          group.workspaceUuid,
+          new Map(group.refs.map((entry) => [`${entry.kind}|${entry.uuid}`, entry]))
+        ])
+      );
+      for (const [workspaceUuid, refs] of chunk) {
+        const byKey = answered.get(workspaceUuid);
+        if (!byKey) continue;
+        for (const ref of refs) {
+          const entry = byKey.get(`${ref.kind}|${ref.uuid}`);
+          if (!entry) continue;
+          const resolution = batchResolution(ref, entry);
+          if (resolution) this.cache.set(this.cacheKey(ref), Promise.resolve(resolution));
+        }
+      }
+    } catch {
+      this.inFlight.delete(key);
+    }
+  }
   async primeWorkspace(workspaceUuid, refs) {
     for (let start = 0; start < refs.length; start += MAX_REFS_PER_BATCH) {
       const chunk = refs.slice(start, start + MAX_REFS_PER_BATCH);
@@ -10612,8 +10699,10 @@ function globalFlags(ctx) {
   return flags;
 }
 function resolverFor(hctx) {
+  const mount = resolveActivityMount(hctx.args);
   return new ActivityRefResolver(requireAuth(hctx.ctx).apiClient, {
-    bare: hctx.args.ids === true
+    bare: hctx.args.ids === true,
+    orgUuid: mount.kind === "org" ? mount.uuid : void 0
   });
 }
 function isAggregate(response) {