@guildai/cli 0.9.0 → 0.9.1

package/dist/lib/npmrc.js

@@ -8,7 +8,8 @@ function getRegistryUrl() {
     const url = getGuildcoreUrl();
     return url.replace('/api', '/npm') + (url.endsWith('/') ? '' : '/');
 }
-const SCOPES = ['@guildai', '@guildai-services', '@guildai-agents'];
+const SCOPES = ['@guildai-services', '@guildai-agents'];
+const LEGACY_SCOPES = ['@guildai'];
 export async function configureNpmrc() {
     const registryUrl = getRegistryUrl();
     const scope = registryUrl.split(':').slice(1).join(':');
@@ -35,7 +36,10 @@ export async function configureNpmrc() {
 export async function cleanupNpmrc() {
     const registryUrl = getRegistryUrl();
     const scope = registryUrl.split(':').slice(1).join(':');
-    const keys = [...SCOPES.map((s) => `${s}:registry`), `${scope}:_authToken`];
+    const keys = [
+        ...[...SCOPES, ...LEGACY_SCOPES].map((s) => `${s}:registry`),
+        `${scope}:_authToken`,
+    ];
     for (const key of keys) {
         try {
             await execa('npm', [

package/dist/lib/session-events.d.ts

@@ -19,10 +19,12 @@ export interface AgentRef {
 }
 export interface SessionTaskAgentItem extends BaseTaskFields {
     agent: AgentRef;
+    parent_task_id: string | null;
 }
 export interface SessionTaskToolItem extends BaseTaskFields {
     tool_name: string;
     tool_call_id: string;
+    parent_task: SessionTaskItem | null;
 }
 export type SessionTaskItem = SessionTaskAgentItem | SessionTaskToolItem;
 export interface SessionTaskAgent extends SessionTaskAgentItem {
@@ -91,26 +93,29 @@ export interface RuntimeDoneEvent extends BaseEvent {
     type: 'runtime_done';
     content: Record<string, unknown>;
 }
+export interface TextContent {
+    type: 'text';
+    data: string;
+}
+export interface ResponseStreamContent {
+    type: 'application/guild-response-stream';
+    stream_id: string;
+    sequence: number;
+    status: 'streaming' | 'done' | 'aborted';
+    text: string;
+}
+export type AgentNotificationMessageContent = TextContent | ResponseStreamContent;
 export interface AgentNotificationMessageEvent extends BaseEvent {
     type: 'agent_notification_message';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: AgentNotificationMessageContent;
 }
 export interface AgentNotificationProgressEvent extends BaseEvent {
     type: 'agent_notification_progress';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: TextContent;
 }
 export interface AgentNotificationErrorEvent extends BaseEvent {
     type: 'agent_notification_error';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: TextContent;
 }
 export interface AgentConsoleEvent extends BaseEvent {
     type: 'agent_console';
@@ -126,10 +131,7 @@ export interface TriggerMessageEvent extends BaseEvent {
 }
 export interface SystemErrorEvent extends BaseEvent {
     type: 'system_error';
-    content: {
-        type: 'text';
-        data: string;
-    };
+    content: TextContent;
     details?: Record<string, unknown>;
 }
 export interface LlmStartEvent extends BaseEvent {
@@ -169,6 +171,20 @@ export interface CredentialsRequestEvent extends BaseEvent {
 export declare function isUnfulfilledAgentInstallRequest(event: SessionEvent): event is AgentInstallRequestEvent;
 /** Check if event is an unfulfilled credentials request */
 export declare function isUnfulfilledCredentialsRequest(event: SessionEvent): event is CredentialsRequestEvent;
+/** Check if an agent notification message is a transient response stream draft. */
+export declare function isResponseStreamEvent(event: SessionEvent): event is AgentNotificationMessageEvent & {
+    content: ResponseStreamContent;
+};
+/** Check if a response stream event carries the final generated text. */
+export declare function isDoneResponseStreamEvent(event: SessionEvent): event is AgentNotificationMessageEvent & {
+    content: ResponseStreamContent & {
+        status: 'done';
+    };
+};
+/** Extract display text from notification content. */
+export declare function getAgentNotificationText(event: AgentNotificationMessageEvent): string;
+/** Check if an event belongs to the root task or has no task context. */
+export declare function isRootTaskEvent(event: SessionEvent): boolean;
 export interface InterruptedEvent extends BaseEvent {
     type: 'interrupted';
     interrupted_at: string;

package/dist/lib/session-events.js

@@ -87,4 +87,26 @@ export function isUnfulfilledAgentInstallRequest(event) {
 export function isUnfulfilledCredentialsRequest(event) {
     return event.type === 'credentials_request' && !event.is_fulfilled;
 }
+/** Check if an agent notification message is a transient response stream draft. */
+export function isResponseStreamEvent(event) {
+    return (event.type === 'agent_notification_message' &&
+        event.content.type === 'application/guild-response-stream');
+}
+/** Check if a response stream event carries the final generated text. */
+export function isDoneResponseStreamEvent(event) {
+    return isResponseStreamEvent(event) && event.content.status === 'done';
+}
+/** Extract display text from notification content. */
+export function getAgentNotificationText(event) {
+    return event.content.type === 'text' ? event.content.data : event.content.text;
+}
+/** Check if an event belongs to the root task or has no task context. */
+export function isRootTaskEvent(event) {
+    const task = event.task;
+    if (!task)
+        return true;
+    if ('parent_task_id' in task)
+        return task.parent_task_id === null;
+    return task.parent_task === null;
+}
 //# sourceMappingURL=session-events.js.map

package/dist/lib/session-polling.d.ts

@@ -11,9 +11,10 @@ export interface PollResult {
  * and one-shot agents (which may only emit runtime_done with output content).
  *
  * Priority:
- * 1. agent_notification_message — preferred, immediate return
- * 2. runtime_done from agent tasks — fallback for one-shot agents
- * 3. runtime_error from agent tasks — fail fast
+ * 1. root agent_notification_message — preferred, immediate return
+ * 2. root runtime_error — fail fast
+ * 3. root runtime_done content — fallback for one-shot agents
+ * 4. root done response-stream after root runtime_done — streaming fallback
  */
 export declare function pollForResponse(client: GuildAPIClient, sessionId: string, afterEventId: string | undefined, maxWaitTime?: number): Promise<PollResult>;
 /**

package/dist/lib/session-polling.js

@@ -3,6 +3,7 @@
 import { debug, isDebugMode } from './errors.js';
 import { shouldShowEvent } from './event-filter.js';
 import { fetchEvents } from './session-events-fetch.js';
+import { getAgentNotificationText, isDoneResponseStreamEvent, isResponseStreamEvent, isRootTaskEvent, } from './session-events.js';
 /**
  * Poll for agent response using from_id cursor.
  *
@@ -10,28 +11,51 @@ import { fetchEvents } from './session-events-fetch.js';
  * and one-shot agents (which may only emit runtime_done with output content).
  *
  * Priority:
- * 1. agent_notification_message — preferred, immediate return
- * 2. runtime_done from agent tasks — fallback for one-shot agents
- * 3. runtime_error from agent tasks — fail fast
+ * 1. root agent_notification_message — preferred, immediate return
+ * 2. root runtime_error — fail fast
+ * 3. root runtime_done content — fallback for one-shot agents
+ * 4. root done response-stream after root runtime_done — streaming fallback
  */
 export async function pollForResponse(client, sessionId, afterEventId, maxWaitTime = 60000) {
     const startTime = Date.now();
     let fromId = afterEventId;
+    let responseStreamDone = null;
     while (Date.now() - startTime < maxWaitTime) {
         const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
+        let rootRuntimeDone = false;
         for (const event of events) {
             debug(`pollForResponse event: ${event.type}`);
             if (event.type === 'agent_notification_message') {
-                return { response: event.content.data, lastEventId: event.id };
+                if (isResponseStreamEvent(event)) {
+                    if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
+                        responseStreamDone = {
+                            response: getAgentNotificationText(event),
+                            lastEventId: event.id,
+                        };
+                    }
+                    continue;
+                }
+                if (!isRootTaskEvent(event))
+                    continue;
+                return {
+                    response: getAgentNotificationText(event),
+                    lastEventId: event.id,
+                };
             }
             if (event.type === 'runtime_done' &&
-                event.content !== undefined &&
                 event.task &&
-                'agent' in event.task) {
-                lastAgentRuntimeDone = JSON.stringify(event.content);
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
+                rootRuntimeDone = true;
+                if (event.content !== undefined) {
+                    lastAgentRuntimeDone = JSON.stringify(event.content);
+                }
             }
-            if (event.type === 'runtime_error' && event.task && 'agent' in event.task) {
+            if (event.type === 'runtime_error' &&
+                event.task &&
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
                 return {
                     response: JSON.stringify({ error: event.content }),
                     lastEventId: event.id,
@@ -47,9 +71,14 @@ export async function pollForResponse(client, sessionId, afterEventId, maxWaitTi
         if (lastAgentRuntimeDone !== null) {
             return { response: lastAgentRuntimeDone, lastEventId: fromId };
         }
+        if (rootRuntimeDone && responseStreamDone !== null) {
+            return { response: responseStreamDone.response, lastEventId: fromId };
+        }
         await new Promise((resolve) => setTimeout(resolve, 2000));
     }
-    return { response: null, lastEventId: fromId };
+    return responseStreamDone
+        ? { response: responseStreamDone.response, lastEventId: fromId }
+        : { response: null, lastEventId: fromId };
 }
 /**
  * Poll for agent response while streaming matching events to stdout as JSONL.
@@ -61,25 +90,49 @@ export async function pollForResponse(client, sessionId, afterEventId, maxWaitTi
 export async function pollForResponseWithEvents(client, sessionId, eventFilter, afterEventId, maxWaitTime = 60000) {
     const startTime = Date.now();
     let fromId = afterEventId;
+    let responseStreamDone = null;
     while (Date.now() - startTime < maxWaitTime) {
         const events = await fetchEvents(client, sessionId, { fromId });
         let lastAgentRuntimeDone = null;
+        let rootRuntimeDone = false;
         for (const event of events) {
             debug(`pollForResponseWithEvents event: ${event.type}`);
-            // Stream matching events to stdout as JSONL
-            if (shouldShowEvent(event.type, eventFilter)) {
+            // Stream matching events to stdout as JSONL. Response-stream events are
+            // transient drafts, so keep automation output stable and wait for the
+            // final agent message or terminal fallback.
+            if (shouldShowEvent(event.type, eventFilter) && !isResponseStreamEvent(event)) {
                 process.stdout.write(JSON.stringify(event) + '\n');
             }
             if (event.type === 'agent_notification_message') {
-                return { response: event.content.data, lastEventId: event.id };
+                if (isResponseStreamEvent(event)) {
+                    if (isRootTaskEvent(event) && isDoneResponseStreamEvent(event)) {
+                        responseStreamDone = {
+                            response: getAgentNotificationText(event),
+                            lastEventId: event.id,
+                        };
+                    }
+                    continue;
+                }
+                if (!isRootTaskEvent(event))
+                    continue;
+                return {
+                    response: getAgentNotificationText(event),
+                    lastEventId: event.id,
+                };
             }
             if (event.type === 'runtime_done' &&
-                event.content !== undefined &&
                 event.task &&
-                'agent' in event.task) {
-                lastAgentRuntimeDone = JSON.stringify(event.content);
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
+                rootRuntimeDone = true;
+                if (event.content !== undefined) {
+                    lastAgentRuntimeDone = JSON.stringify(event.content);
+                }
             }
-            if (event.type === 'runtime_error' && event.task && 'agent' in event.task) {
+            if (event.type === 'runtime_error' &&
+                event.task &&
+                'agent' in event.task &&
+                isRootTaskEvent(event)) {
                 return {
                     response: JSON.stringify({ error: event.content }),
                     lastEventId: event.id,
@@ -95,8 +148,13 @@ export async function pollForResponseWithEvents(client, sessionId, eventFilter,
         if (lastAgentRuntimeDone !== null) {
             return { response: lastAgentRuntimeDone, lastEventId: fromId };
         }
+        if (rootRuntimeDone && responseStreamDone !== null) {
+            return { response: responseStreamDone.response, lastEventId: fromId };
+        }
         await new Promise((resolve) => setTimeout(resolve, 2000));
     }
-    return { response: null, lastEventId: fromId };
+    return responseStreamDone
+        ? { response: responseStreamDone.response, lastEventId: fromId }
+        : { response: null, lastEventId: fromId };
 }
 //# sourceMappingURL=session-polling.js.map

package/dist/lib/session-resume.js

@@ -7,6 +7,7 @@
 import chalk from 'chalk';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
+import { getAgentNotificationText, isResponseStreamEvent, } from './session-events.js';
 import { fetchEvents } from './session-events-fetch.js';
 import { brand, code as codeColor } from './colors.js';
 // Configure marked for terminal rendering (same config as chat.tsx)
@@ -64,7 +65,9 @@ export function eventsToDisplayMessages(events) {
             });
         }
         else if (event.type === 'agent_notification_message') {
-            const text = typeof event.content === 'string' ? event.content : event.content?.data || '';
+            if (isResponseStreamEvent(event))
+                continue;
+            const text = getAgentNotificationText(event);
             if (text.trim()) {
                 const rendered = renderMarkdown(text);
                 const messageContent = `${chalk.green('●')} ${chalk.bold('assistant')}\n${rendered.trim()}`;

package/dist/lib/stdin.d.ts

@@ -8,6 +8,10 @@ export declare function isInteractive(): boolean;
  * accidentally pipe input without --mode get clear guidance instead of a hang.
  */
 export declare function ensureInteractiveStdin(command: string): void;
+/**
+ * Read raw text from stdin with a timeout.
+ */
+export declare function readStdinAsText(): Promise<string>;
 /**
  * Read JSON from stdin with a timeout.
  */

package/dist/lib/stdin.js

@@ -24,6 +24,29 @@ export function ensureInteractiveStdin(command) {
         process.exit(1);
     }
 }
+/**
+ * Read raw text from stdin with a timeout.
+ */
+export function readStdinAsText() {
+    return new Promise((resolve, reject) => {
+        let input = '';
+        const timeout = setTimeout(() => {
+            reject(new Error('Timeout waiting for stdin'));
+        }, 5000);
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            input += chunk;
+        });
+        process.stdin.on('end', () => {
+            clearTimeout(timeout);
+            resolve(input);
+        });
+        process.stdin.on('error', (error) => {
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+}
 /**
  * Read JSON from stdin with a timeout.
  */

package/dist/lib/validate-input-schema.d.ts

@@ -0,0 +1,19 @@
+interface ValidationSuccess {
+    valid: true;
+}
+interface ValidationFailure {
+    valid: false;
+    errors: Array<{
+        message: string;
+        path?: string[];
+    }>;
+}
+interface ValidationSkipped {
+    valid: true;
+    skipped: true;
+    reason: string;
+}
+export type ValidationResult = ValidationSuccess | ValidationFailure | ValidationSkipped;
+export declare function validateInputSchema(agentDir: string, inputs: unknown[]): Promise<ValidationResult>;
+export {};
+//# sourceMappingURL=validate-input-schema.d.ts.map

package/dist/lib/validate-input-schema.js

@@ -0,0 +1,208 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { debug } from './errors.js';
+const execFileAsync = promisify(execFile);
+function resolveSourceEntryPoint(agentDir, packageJson) {
+    const exports = packageJson.exports;
+    if (exports?.['.']) {
+        const distPath = exports['.'];
+        const sourcePath = distPath
+            .replace(/^\.\/dist\//, '')
+            .replace(/\.compiled\.js$/, '.ts')
+            .replace(/\.js$/, '.ts');
+        return path.join(agentDir, sourcePath);
+    }
+    return path.join(agentDir, 'agent.ts');
+}
+async function fileExists(filePath) {
+    return fs
+        .access(filePath)
+        .then(() => true)
+        .catch(() => false);
+}
+/**
+ * Extract a single `const <name> = z.<call>(...)` declaration from source,
+ * starting at the given regex match. Uses balanced parenthesis matching
+ * with string literal awareness.
+ */
+function extractZodDeclaration(source, match) {
+    const startIndex = match.index;
+    const afterEquals = match.index + match[0].length;
+    let depth = 0;
+    let foundOpen = false;
+    let endIndex = afterEquals;
+    let inString = null;
+    for (let charIndex = afterEquals; charIndex < source.length; charIndex++) {
+        const char = source[charIndex];
+        if (inString) {
+            if (char === '\\') {
+                charIndex++;
+            }
+            else if (char === inString) {
+                inString = null;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            inString = char;
+        }
+        else if (char === '(') {
+            depth++;
+            foundOpen = true;
+        }
+        else if (char === ')') {
+            depth--;
+            if (foundOpen && depth === 0) {
+                endIndex = charIndex + 1;
+                if (source[endIndex] === ';')
+                    endIndex++;
+                break;
+            }
+        }
+    }
+    if (!foundOpen)
+        return null;
+    return source.substring(startIndex, endIndex);
+}
+/**
+ * Extract inputSchema and any Zod schema dependencies from agent source.
+ * Finds all `const <name> = z.<call>(...)` declarations that appear before
+ * inputSchema (which may be referenced inside it), plus inputSchema itself.
+ * Returns them in source order so dependencies are defined before use.
+ */
+function extractInputSchema(source) {
+    const inputPattern = /const\s+inputSchema\s*=\s*/;
+    const inputMatch = inputPattern.exec(source);
+    if (!inputMatch)
+        return null;
+    const inputBlock = extractZodDeclaration(source, inputMatch);
+    if (!inputBlock)
+        return null;
+    const blocks = [];
+    const zodDeclPattern = /const\s+\w+\s*=\s*z\s*\.\s*/g;
+    let declMatch;
+    while ((declMatch = zodDeclPattern.exec(source)) !== null) {
+        if (declMatch.index >= inputMatch.index)
+            break;
+        const block = extractZodDeclaration(source, declMatch);
+        if (block)
+            blocks.push(block);
+    }
+    blocks.push(inputBlock);
+    return blocks.join('\n');
+}
+export async function validateInputSchema(agentDir, inputs) {
+    const nodeModulesPath = path.join(agentDir, 'node_modules');
+    if (!(await fileExists(nodeModulesPath))) {
+        return {
+            valid: true,
+            skipped: true,
+            reason: 'run npm install for pre-build input validation',
+        };
+    }
+    const pkgJsonPath = path.join(agentDir, 'package.json');
+    if (!(await fileExists(pkgJsonPath))) {
+        return {
+            valid: true,
+            skipped: true,
+            reason: 'no package.json found',
+        };
+    }
+    const pkgJson = JSON.parse(await fs.readFile(pkgJsonPath, 'utf-8'));
+    let entryPoint = resolveSourceEntryPoint(agentDir, pkgJson);
+    if (!(await fileExists(entryPoint))) {
+        const fallback = path.join(agentDir, 'agent.ts');
+        if (await fileExists(fallback)) {
+            entryPoint = fallback;
+        }
+        else {
+            return {
+                valid: true,
+                skipped: true,
+                reason: `could not find agent source file (tried ${path.basename(entryPoint)})`,
+            };
+        }
+    }
+    const agentSource = await fs.readFile(entryPoint, 'utf-8');
+    const schemaBlock = extractInputSchema(agentSource);
+    if (!schemaBlock) {
+        return {
+            valid: true,
+            skipped: true,
+            reason: 'could not find inputSchema definition in agent source',
+        };
+    }
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'guild-validate-'));
+    try {
+        const extractorSource = [
+            `import { z } from "zod";`,
+            schemaBlock,
+            `const inputs = JSON.parse(process.argv[2]);`,
+            `const errors = [];`,
+            `for (let i = 0; i < inputs.length; i++) {`,
+            `  try {`,
+            `    inputSchema.parse(inputs[i]);`,
+            `  } catch (e) {`,
+            `    const issues = e.issues || [{ message: e.message }];`,
+            `    errors.push({ index: i, issues: issues.map(iss => ({ message: iss.message, path: iss.path })) });`,
+            `  }`,
+            `}`,
+            `if (errors.length > 0) {`,
+            `  console.log(JSON.stringify({ valid: false, errors }));`,
+            `} else {`,
+            `  console.log(JSON.stringify({ valid: true }));`,
+            `}`,
+        ].join('\n');
+        const extractorPath = path.join(tmpDir, 'validate.mjs');
+        await fs.writeFile(extractorPath, extractorSource);
+        const { build } = await import('esbuild');
+        const bundlePath = path.join(tmpDir, 'validate-bundle.mjs');
+        await build({
+            entryPoints: [extractorPath],
+            bundle: true,
+            format: 'esm',
+            target: 'esnext',
+            platform: 'node',
+            outfile: bundlePath,
+            logLevel: 'silent',
+            nodePaths: [path.join(agentDir, 'node_modules')],
+        });
+        const inputArg = JSON.stringify(inputs);
+        const { stdout } = await execFileAsync('node', [bundlePath, inputArg], {
+            cwd: agentDir,
+            timeout: 10000,
+        });
+        const result = JSON.parse(stdout.trim());
+        if (result.valid) {
+            return { valid: true };
+        }
+        const flatErrors = [];
+        for (const entry of result.errors) {
+            for (const issue of entry.issues) {
+                const prefix = inputs.length > 1 ? `Line ${entry.index + 1}: ` : '';
+                flatErrors.push({
+                    message: `${prefix}${issue.message}`,
+                    path: issue.path,
+                });
+            }
+        }
+        return { valid: false, errors: flatErrors };
+    }
+    catch (error) {
+        debug('Local input validation failed: %s', error);
+        return {
+            valid: true,
+            skipped: true,
+            reason: 'local validation encountered an error (server-side validation will still run)',
+        };
+    }
+    finally {
+        await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+//# sourceMappingURL=validate-input-schema.js.map

package/dist/lib/workspace-helpers.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Workspace resolution helper for workspace subcommands.
+ *
+ * Resolves a workspace identifier (UUID or human-readable name) to a UUID.
+ * Used by `guild workspace agent add`, `list`, and `remove`.
+ */
+import { GuildAPIClient } from './api-client.js';
+/**
+ * Resolve a workspace ID or name to a workspace UUID.
+ *
+ * UUID inputs pass through unchanged. Name inputs are resolved by searching
+ * the user's workspaces via `GET /me/workspaces?filter=all&search=...` first,
+ * with a `fetchAll` fallback for IDs and names not matched by the search.
+ *
+ * Throws an `Error` with message `Workspace "<idOrName>" not found` if
+ * nothing resolves — callers should catch this and call `output.error` +
+ * `process.exit(1)`.
+ */
+export declare function resolveWorkspaceId(client: GuildAPIClient, idOrName: string): Promise<string>;
+//# sourceMappingURL=workspace-helpers.d.ts.map

package/dist/lib/workspace-helpers.js

@@ -0,0 +1,49 @@
+// Copyright 2026 Guild.ai
+// SPDX-License-Identifier: Apache-2.0
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+ * Match a workspace against a search argument (case-insensitive name, full_name, or exact ID).
+ */
+function matchesWorkspaceArg(w, arg) {
+    return (w.id === arg ||
+        w.name === arg ||
+        w.name.toLowerCase() === arg.toLowerCase() ||
+        w.full_name === arg ||
+        w.full_name?.toLowerCase() === arg.toLowerCase());
+}
+/**
+ * Resolve a workspace ID or name to a workspace UUID.
+ *
+ * UUID inputs pass through unchanged. Name inputs are resolved by searching
+ * the user's workspaces via `GET /me/workspaces?filter=all&search=...` first,
+ * with a `fetchAll` fallback for IDs and names not matched by the search.
+ *
+ * Throws an `Error` with message `Workspace "<idOrName>" not found` if
+ * nothing resolves — callers should catch this and call `output.error` +
+ * `process.exit(1)`.
+ */
+export async function resolveWorkspaceId(client, idOrName) {
+    // Short-circuit UUID inputs — pass through unchanged
+    if (UUID_RE.test(idOrName)) {
+        return idOrName;
+    }
+    // Use server-side search first. Extract just the name part for full_name
+    // inputs (e.g. "owner/workspace-name") since the backend searches by name.
+    const searchTerm = idOrName.includes('/')
+        ? (idOrName.split('/').pop() ?? idOrName)
+        : idOrName;
+    const searchResults = await client.get(`/me/workspaces?filter=all&search=${encodeURIComponent(searchTerm)}&limit=100`);
+    const directMatch = searchResults.items.find((w) => matchesWorkspaceArg(w, idOrName));
+    if (directMatch) {
+        return directMatch.id;
+    }
+    // Fall back to fetching all workspaces (handles IDs and names not returned
+    // by search, e.g. when the backend's ILIKE search doesn't match full_name).
+    const allWorkspaces = await client.fetchAll('/me/workspaces?filter=all');
+    const fallbackMatch = allWorkspaces.find((w) => matchesWorkspaceArg(w, idOrName));
+    if (fallbackMatch) {
+        return fallbackMatch.id;
+    }
+    throw new Error(`Workspace "${idOrName}" not found`);
+}
+//# sourceMappingURL=workspace-helpers.js.map