@outputai/cli 0.14.1-next.bd031f8.0 → 0.14.1-next.e9dfa49.0

package/dist/api/generated/api.d.ts

@@ -289,9 +289,9 @@ export interface WorkflowResultV1Response {
     runId: string | null;
     status: WorkflowResultStatus;
     /** The original input passed to the workflow, null if unavailable */
-    input: unknown | null;
+    input: unknown;
     /** The result of workflow, null if workflow failed */
-    output: unknown | null;
+    output: unknown;
     trace: TraceInfoV1 | null;
     /**
        * Error message if workflow failed, null otherwise
@@ -326,9 +326,9 @@ export interface WorkflowResultV2Response {
     runId: string | null;
     status: WorkflowResultStatus;
     /** The original input passed to the workflow, null if unavailable */
-    input: unknown | null;
+    input: unknown;
     /** Direct workflow output, null if no output is available */
-    output: unknown | null;
+    output: unknown;
     trace: TraceInfoV2 | null;
     error: SerializedWorkflowError | null;
 }
@@ -390,6 +390,12 @@ export type ServiceUnavailableResponse = ErrorResponse;
  * Internal server error (e.g. Temporal connection failure)
  */
 export type InternalServerErrorResponse = ErrorResponse;
+/**
+ * (Optional) Temporal search attributes to set on the execution. Each attribute must be registered on the namespace. Values are scalars (string, number, boolean) or string arrays (KeywordList). Unregistered names or values that do not match the registered type are rejected with 400.
+ */
+export type PostWorkflowRunBodySearchAttributes = {
+    [key: string]: string | number | boolean | string[];
+};
 export type PostWorkflowRunBody = {
     /** The name of the workflow to execute */
     workflowName: string;
@@ -404,9 +410,17 @@ export type PostWorkflowRunBody = {
        * @deprecated
        */
     taskQueue?: string;
+    /** (Optional) Temporal search attributes to set on the execution. Each attribute must be registered on the namespace. Values are scalars (string, number, boolean) or string arrays (KeywordList). Unregistered names or values that do not match the registered type are rejected with 400. */
+    searchAttributes?: PostWorkflowRunBodySearchAttributes;
     /** (Optional) The max time to wait for the execution, defaults to 30s */
     timeout?: number;
 };
+/**
+ * (Optional) Temporal search attributes to set on the execution. Each attribute must be registered on the namespace. Values are scalars (string, number, boolean) or string arrays (KeywordList). Unregistered names or values that do not match the registered type are rejected with 400.
+ */
+export type PostWorkflowStartBodySearchAttributes = {
+    [key: string]: string | number | boolean | string[];
+};
 export type PostWorkflowStartBody = {
     /** The name of the workflow to execute */
     workflowName: string;
@@ -421,6 +435,8 @@ export type PostWorkflowStartBody = {
        * @deprecated
        */
     taskQueue?: string;
+    /** (Optional) Temporal search attributes to set on the execution. Each attribute must be registered on the namespace. Values are scalars (string, number, boolean) or string arrays (KeywordList). Unregistered names or values that do not match the registered type are rejected with 400. */
+    searchAttributes?: PostWorkflowStartBodySearchAttributes;
 };
 export type PostWorkflowStart200 = {
     /** The id of the started workflow */

package/dist/api/generated/api.js

@@ -78,10 +78,25 @@ export const getPostWorkflowRunUrl = () => {
  * @summary Execute a workflow synchronously
  */
 export const postWorkflowRun = async (postWorkflowRunBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowRunUrl(), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowRunBody)
     });
 };
@@ -92,10 +107,25 @@ export const getPostWorkflowStartUrl = () => {
  * @summary Start a workflow asynchronously
  */
 export const postWorkflowStart = async (postWorkflowStartBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowStartUrl(), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowStartBody)
     });
 };
@@ -158,10 +188,25 @@ export const getPostWorkflowIdRunsRidTerminateUrl = (id, rid) => {
  * @summary Terminate a specific workflow run (force stop)
  */
 export const postWorkflowIdRunsRidTerminate = async (id, rid, postWorkflowIdRunsRidTerminateBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdRunsRidTerminateUrl(id, rid), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowIdRunsRidTerminateBody)
     });
 };
@@ -174,10 +219,25 @@ export const getPostWorkflowIdTerminateUrl = (id) => {
  * @summary [Deprecated] Terminate the latest workflow run
  */
 export const postWorkflowIdTerminate = async (id, postWorkflowIdTerminateBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdTerminateUrl(id), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowIdTerminateBody)
     });
 };
@@ -189,10 +249,25 @@ export const getPostWorkflowIdRunsRidResetUrl = (id, rid) => {
  * @summary Reset a specific workflow run to re-run from after a completed step
  */
 export const postWorkflowIdRunsRidReset = async (id, rid, resetWorkflowRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdRunsRidResetUrl(id, rid), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(resetWorkflowRequest)
     });
 };
@@ -205,10 +280,25 @@ export const getPostWorkflowIdResetUrl = (id) => {
  * @summary [Deprecated] Reset the latest workflow run
  */
 export const postWorkflowIdReset = async (id, resetWorkflowRequest, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdResetUrl(id), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(resetWorkflowRequest)
     });
 };
@@ -419,10 +509,25 @@ export const getPostWorkflowIdFeedbackUrl = (id) => {
  * @summary Send feedback to a workflow
  */
 export const postWorkflowIdFeedback = async (id, postWorkflowIdFeedbackBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdFeedbackUrl(id), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowIdFeedbackBody)
     });
 };
@@ -434,10 +539,25 @@ export const getPostWorkflowIdSignalSignalUrl = (id, signal) => {
  * @summary Send a signal to an workflow
  */
 export const postWorkflowIdSignalSignal = async (id, signal, postWorkflowIdSignalSignalBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdSignalSignalUrl(id, signal), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowIdSignalSignalBody)
     });
 };
@@ -449,10 +569,25 @@ export const getPostWorkflowIdQueryQueryUrl = (id, query) => {
  * @summary Send a query to an workflow
  */
 export const postWorkflowIdQueryQuery = async (id, query, postWorkflowIdQueryQueryBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdQueryQueryUrl(id, query), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowIdQueryQueryBody)
     });
 };
@@ -464,10 +599,25 @@ export const getPostWorkflowIdUpdateUpdateUrl = (id, update) => {
  * @summary Execute an update on an workflow
  */
 export const postWorkflowIdUpdateUpdate = async (id, update, postWorkflowIdUpdateUpdateBody, options) => {
+    const getHeaders = (h) => {
+        if (!h)
+            return {};
+        if (h instanceof Headers)
+            return Object.fromEntries(h.entries());
+        if (Symbol.iterator in h) {
+            return Object.fromEntries(Array.from(h, (entry) => Array.from(entry)));
+        }
+        const headers = {};
+        for (const [name, value] of Object.entries(h)) {
+            if (value !== undefined)
+                headers[name] = value;
+        }
+        return headers;
+    };
     return customFetchInstance(getPostWorkflowIdUpdateUpdateUrl(id, update), {
         ...options,
         method: 'POST',
-        headers: { 'Content-Type': 'application/json', ...options?.headers },
+        headers: { 'Content-Type': 'application/json', ...getHeaders(options?.headers) },
         body: JSON.stringify(postWorkflowIdUpdateUpdateBody)
     });
 };

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.14.1-next.bd031f8.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.14.1-next.e9dfa49.0}
     init: true
     networks:
       - main

package/dist/commands/credentials/get.js

@@ -1,6 +1,6 @@
 import { Args, Command, Flags } from '@oclif/core';
 import { load as parseYaml } from 'js-yaml';
-import { getNestedValue } from '@outputai/credentials';
+import { getNestedValue } from '@outputai/core/credentials';
 import { decryptCredentials, credentialsExist, resolveCredentialsPath } from '#services/credentials_service.js';
 export default class CredentialsGet extends Command {
     static description = 'Get a specific credential value by dot-notation path';

package/dist/commands/credentials/get.spec.js

@@ -6,7 +6,7 @@ vi.mock('#services/credentials_service.js');
 vi.mock('js-yaml', () => ({
     load: vi.fn((yaml) => ({ anthropic: { api_key: yaml.includes('sk-test') ? 'sk-test' : undefined } }))
 }));
-vi.mock('@outputai/credentials', () => ({
+vi.mock('@outputai/core/credentials', () => ({
     getNestedValue: vi.fn((obj, path) => {
         const parts = path.split('.');
         return parts.reduce((acc, part) => acc?.[part], obj);

package/dist/commands/fix.js

@@ -9,7 +9,7 @@ const Ansi = {
     RESET: '\x1b[0m'
 };
 export default class Fix extends Command {
-    static description = 'Fix Output scripts in the package.json (reset overwrites, add missing and remove deprecated)';
+    static description = 'Fix Output scripts in the package.json (reset overwrites, add missing and remove deprecated) and remove stale hook files';
     static examples = [
         '<%= config.bin %> <%= command.id %>'
     ];
@@ -30,6 +30,10 @@ export default class Fix extends Command {
             this.log('\n  Scripts to remove:');
             plan.scriptsToRemove.forEach(({ key }) => this.log(`    ${Ansi.RED}-${Ansi.RESET} "${key}"`));
         }
+        if (plan.hookFilesToRemove.length > 0) {
+            this.log('\n  Hook files to remove:');
+            plan.hookFilesToRemove.forEach(file => this.log(`    ${Ansi.RED}-${Ansi.RESET} "${file}"`));
+        }
         this.log('');
     }
     async run() {

package/dist/commands/fix.spec.js

@@ -16,7 +16,8 @@ const basePlan = () => ({
     hasChanges: true,
     scriptsToRemove: [{ key: 'dev', value: 'old' }],
     scriptsToAdd: [{ key: 'output:new', value: 'echo new' }],
-    scriptsToReplace: [{ key: 'output:dev', before: 'old dev', after: 'output dev' }]
+    scriptsToReplace: [{ key: 'output:dev', before: 'old dev', after: 'output dev' }],
+    hookFilesToRemove: []
 });
 describe('fix command', () => {
     const createTestCommand = () => {
@@ -59,6 +60,17 @@ describe('fix command', () => {
         expect(fixService.applyFix).toHaveBeenCalledTimes(1);
         expect(cmd.log).toHaveBeenCalledWith('Done, package.json is properly configured.');
     });
+    it('should list hook files to remove', async () => {
+        vi.mocked(fixService.planFix).mockReturnValue({
+            ...basePlan(),
+            hookFilesToRemove: ['node_modules/@outputai/credentials/dist/hooks.js']
+        });
+        vi.mocked(confirm).mockResolvedValue(false);
+        const cmd = createTestCommand();
+        await cmd.run();
+        expect(cmd.log).toHaveBeenCalledWith('\n  Hook files to remove:');
+        expect(cmd.log).toHaveBeenCalledWith(expect.stringContaining('"node_modules/@outputai/credentials/dist/hooks.js"'));
+    });
     it('should not apply when user declines', async () => {
         vi.mocked(fixService.planFix).mockReturnValue(basePlan());
         vi.mocked(confirm).mockResolvedValue(false);

package/dist/commands/workflow/run.d.ts

@@ -11,6 +11,7 @@ export default class WorkflowRun extends Command {
     static flags: {
         input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'search-attributes': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<WorkflowResultResponse>;
     catch(error: Error): Promise<void>;

package/dist/commands/workflow/run.js

@@ -3,6 +3,7 @@ import { postWorkflowRun } from '#api/generated/api.js';
 import { formatWorkflowResult, isErrorStatus } from '#utils/format_workflow_result.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { resolveInput } from '#utils/resolve_input.js';
+import { parseSearchAttributesFlag } from '#utils/search_attributes_flag.js';
 import { getRetryDelayFromResponse } from '#utils/header_utils.js';
 import { sleep } from '#utils/sleep.js';
 import { HttpError } from '#api/http_client.js';
@@ -34,7 +35,8 @@ export default class WorkflowRun extends Command {
         '<%= config.bin %> <%= command.id %> simple my_scenario --json',
         '<%= config.bin %> <%= command.id %> simple --input \'{"values":[1,2,3]}\'',
         '<%= config.bin %> <%= command.id %> simple --input input.json',
-        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog'
+        '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog',
+        '<%= config.bin %> <%= command.id %> simple basic_input --search-attributes \'{"ClientId":"acme"}\''
     ];
     static args = {
         workflowName: Args.string({
@@ -59,10 +61,17 @@ export default class WorkflowRun extends Command {
             deprecateAliases: true,
             description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
             env: 'OUTPUT_CATALOG_ID'
+        }),
+        'search-attributes': Flags.string({
+            char: 'a',
+            description: 'Temporal search attributes as a JSON object or file path, e.g. {"ClientId":"acme"}. ' +
+                'Each attribute must be registered on the namespace',
+            required: false
         })
     };
     async run() {
         const { args, flags } = await this.parse(WorkflowRun);
+        const searchAttributes = parseSearchAttributesFlag(flags['search-attributes']);
         const input = await resolveInput({
             workflowName: args.workflowName,
             scenario: args.scenario,
@@ -76,7 +85,8 @@ export default class WorkflowRun extends Command {
             body: {
                 workflowName: args.workflowName,
                 input,
-                catalog: flags.catalog
+                catalog: flags.catalog,
+                searchAttributes
             },
             options: { config: { timeout: 600000 } },
             log: msg => this.log(msg)

package/dist/commands/workflow/run.spec.js

@@ -114,6 +114,29 @@ describe('workflow run command', () => {
             }));
             expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ catalog: 'my-catalog' }), expect.anything());
         });
+        it('passes --search-attributes to postWorkflowRun', async () => {
+            const { cmd, postWorkflowRun } = await createCommand();
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: 'basic' },
+                flags: { input: undefined, catalog: undefined, 'search-attributes': '{"ClientId":"acme"}', format: 'text' }
+            });
+            postWorkflowRun.mockResolvedValue({
+                data: { v: '2', workflowId: 'wf-1', runId: 'run-1', status: 'completed', input: {}, output: {}, trace: null, error: null },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(postWorkflowRun).toHaveBeenCalledWith(expect.objectContaining({ searchAttributes: { ClientId: 'acme' } }), expect.anything());
+        });
+        it('rejects invalid --search-attributes before calling the API', async () => {
+            const { cmd, postWorkflowRun } = await createCommand();
+            cmd.parse = vi.fn().mockResolvedValue({
+                args: { workflowName: 'my_workflow', scenario: 'basic' },
+                flags: { input: undefined, catalog: undefined, 'search-attributes': '["acme"]', format: 'text' }
+            });
+            await expect(cmd.run()).rejects.toThrow('--search-attributes must be a JSON object');
+            expect(postWorkflowRun).not.toHaveBeenCalled();
+        });
         it('retries when response has Retry-After and succeeds on second attempt', async () => {
             const { cmd, postWorkflowRun, resolveInput } = await createCommand();
             resolveInput.mockResolvedValue({});

package/dist/commands/workflow/start.d.ts

@@ -14,6 +14,7 @@ export default class WorkflowStart extends Command {
         color: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         input: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'search-attributes': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         monitor: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<PostWorkflowStart200>;

package/dist/commands/workflow/start.js

@@ -5,6 +5,7 @@ import { handleApiError, handleCommandError } from '#utils/error_handler.js';
 import { isErrorStatus } from '#utils/format_workflow_result.js';
 import { gatedMonitorStreamFlags, MONITOR_DEFAULTS } from '#utils/monitor_flags.js';
 import { resolveInput } from '#utils/resolve_input.js';
+import { parseSearchAttributesFlag } from '#utils/search_attributes_flag.js';
 /**
  * Distinct from 1 (the workflow itself failed) and 2 (usage): the workflow was
  * started and is still running, only the attached stream gave up. A caller that
@@ -20,6 +21,7 @@ export default class WorkflowStart extends Command {
         '<%= config.bin %> <%= command.id %> simple --input input.json',
         '<%= config.bin %> <%= command.id %> simple --input input.json --monitor',
         '<%= config.bin %> <%= command.id %> simple --input \'{"key":"value"}\' --catalog my-catalog',
+        '<%= config.bin %> <%= command.id %> simple basic_input --search-attributes \'{"ClientId":"acme"}\'',
         '<%= config.bin %> <%= command.id %> simple --json'
     ];
     static args = {
@@ -46,6 +48,12 @@ export default class WorkflowStart extends Command {
             description: 'Catalog name for workflow execution (defaults to OUTPUT_CATALOG_ID)',
             env: 'OUTPUT_CATALOG_ID'
         }),
+        'search-attributes': Flags.string({
+            char: 'a',
+            description: 'Temporal search attributes as a JSON object or file path, e.g. {"ClientId":"acme"}. ' +
+                'Each attribute must be registered on the namespace',
+            required: false
+        }),
         // No `default: false`: a defaulted flag counts as present, so it would
         // satisfy the `dependsOn` guard the three flags in `gatedMonitorStreamFlags`
         // point at, letting `--interval` and friends be accepted (and then ignored)
@@ -76,6 +84,7 @@ export default class WorkflowStart extends Command {
             this.error('Cannot combine --monitor with --json. Use "workflow run --json" to wait for the result, ' +
                 'or "workflow monitor <id> --format json" to stream newline-delimited JSON.', { exit: 2 });
         }
+        const searchAttributes = parseSearchAttributesFlag(flags['search-attributes']);
         const input = await resolveInput({
             workflowName: args.workflowName,
             scenario: args.scenario,
@@ -88,7 +97,8 @@ export default class WorkflowStart extends Command {
         const response = await postWorkflowStart({
             workflowName: args.workflowName,
             input,
-            catalog: flags.catalog
+            catalog: flags.catalog,
+            searchAttributes
         });
         if (!response || !response.data) {
             this.error('API returned invalid response', { exit: 1 });

package/dist/commands/workflow/start.spec.js

@@ -140,6 +140,33 @@ describe('workflow start command', () => {
             expect(postWorkflowStart).toHaveBeenCalledWith(expect.objectContaining({ workflowName: 'my_workflow', catalog: 'my-catalog' }));
             expect(result).toEqual({ workflowId: 'wf-123' });
         });
+        it('passes --search-attributes to postWorkflowStart', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand({ 'search-attributes': '{"ClientId":"acme","Tags":["a"]}' });
+            resolveInput.mockResolvedValue({});
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(postWorkflowStart).toHaveBeenCalledWith(expect.objectContaining({ searchAttributes: { ClientId: 'acme', Tags: ['a'] } }));
+        });
+        it('omits searchAttributes when --search-attributes is not set', async () => {
+            const { cmd, postWorkflowStart, resolveInput } = await createCommand();
+            resolveInput.mockResolvedValue({});
+            postWorkflowStart.mockResolvedValue({
+                data: { workflowId: 'wf-123' },
+                status: 200,
+                headers: new Headers()
+            });
+            await cmd.run();
+            expect(postWorkflowStart.mock.calls[0][0].searchAttributes).toBeUndefined();
+        });
+        it('rejects invalid --search-attributes before calling the API', async () => {
+            const { cmd, postWorkflowStart } = await createCommand({ 'search-attributes': '{"ClientId":{"id":1}}' });
+            await expect(cmd.run()).rejects.toThrow('must be a string, number, boolean, or array of strings');
+            expect(postWorkflowStart).not.toHaveBeenCalled();
+        });
         it('passes undefined catalog through when none is set', async () => {
             const { cmd, postWorkflowStart, resolveInput } = await createCommand();
             resolveInput.mockResolvedValue({});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.14.1-next.bd031f8.0"
+    "framework": "0.14.1-next.e9dfa49.0"
 }

package/dist/services/cost_calculator.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import yaml from 'js-yaml';
+import { load as parseYaml } from 'js-yaml';
 const ARRAY_ACCESS_PATTERN = /^(\w+)\[(\d+)\]$/;
 function tokenCost(tokens, pricePerMillion) {
     return (tokens / 1_000_000) * pricePerMillion;
@@ -144,7 +144,7 @@ export function extractValue(obj, path) {
     }, obj);
 }
 function loadYaml(filePath) {
-    return yaml.load(readFileSync(filePath, 'utf-8'));
+    return parseYaml(readFileSync(filePath, 'utf-8'));
 }
 export function loadPricingConfig(configPath) {
     const bundledPath = new URL('../assets/config/costs.yml', import.meta.url).pathname;

package/dist/services/cost_calculator.spec.js

@@ -7,7 +7,7 @@ vi.mock('node:fs', () => ({
 }));
 const mockLoad = vi.fn();
 vi.mock('js-yaml', () => ({
-    default: { load: (...args) => mockLoad(...args) }
+    load: (...args) => mockLoad(...args)
 }));
 import { extractValue, findLLMCalls, findHTTPCalls, identifyService, calculateServiceCost, calculateCost, loadPricingConfig } from '#services/cost_calculator.js';
 // ---------------------------------------------------------------------------

package/dist/services/credentials_service.integration.test.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { load as parseYaml } from 'js-yaml';
-import { encrypt, decrypt, generateKey } from '@outputai/credentials';
+import { encrypt, decrypt, generateKey } from '@outputai/core/credentials';
 import { initCredentials, decryptCredentials, writeEncrypted, checkKeyMatchesCredentials } from './credentials_service.js';
 describe('credentials service integration', () => {
     const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'output-creds-'));

package/dist/services/credentials_service.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { dump as stringifyYaml } from 'js-yaml';
-import { encrypt, decrypt, generateKey, resolveCredentialsPath as resolveCredPath, resolveKeyPath as resolveKPath, resolveKeyEnvVar, resolveWorkflowCredentialsPath, resolveWorkflowKeyPath, resolveWorkflowKeyEnvVar } from '@outputai/credentials';
+import { encrypt, decrypt, generateKey, resolveCredentialsPath as resolveCredPath, resolveKeyPath as resolveKPath, resolveKeyEnvVar, resolveWorkflowCredentialsPath, resolveWorkflowKeyPath, resolveWorkflowKeyEnvVar } from '@outputai/core/credentials';
 const WORKFLOWS_DIR = path.join('src', 'workflows');
 const resolveWorkflowDir = (workflow) => path.resolve(process.cwd(), WORKFLOWS_DIR, workflow);
 export const resolveCredentialsPath = (environment, workflow) => workflow ?

package/dist/services/credentials_service.spec.js

@@ -8,7 +8,7 @@ vi.mock('node:fs', () => ({
         mkdirSync: vi.fn()
     }
 }));
-vi.mock('@outputai/credentials', async (importOriginal) => ({
+vi.mock('@outputai/core/credentials', async (importOriginal) => ({
     ...(await importOriginal()),
     encrypt: vi.fn((plaintext) => `encrypted:${plaintext}`),
     decrypt: vi.fn((ciphertext) => ciphertext.replace('encrypted:', '')),

package/dist/services/datasets.js

@@ -1,7 +1,7 @@
 import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { resolve, join } from 'node:path';
-import yaml from 'js-yaml';
+import { load as parseYaml, dump as stringifyYaml } from 'js-yaml';
 import { DatasetSchema } from '@outputai/evals';
 import { getTrace } from '#services/trace_reader.js';
 import { sanitizeSecrets } from '#utils/secret_sanitizer.js';
@@ -27,7 +27,7 @@ export async function resolveDefaultDatasetsDir(workflowName, basePath, workflow
     return resolve(basePath ?? getWorkflowsBasePath(), WORKFLOWS_PATHS[0], workflowName, DATASETS_DIR);
 }
 export async function readDatasetFile(filePath) {
-    const raw = yaml.load(await readFile(filePath, 'utf-8'));
+    const raw = parseYaml(await readFile(filePath, 'utf-8'));
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
         throw new Error(`Invalid dataset file: ${filePath}`);
     }
@@ -69,13 +69,13 @@ export async function writeDataset(dataset, filePath) {
     if (!existsSync(dir)) {
         await mkdir(dir, { recursive: true });
     }
-    const loaded = existsSync(filePath) ? yaml.load(await readFile(filePath, 'utf-8')) : null;
+    const loaded = existsSync(filePath) ? parseYaml(await readFile(filePath, 'utf-8')) : null;
     const fileObj = (loaded && typeof loaded === 'object' && !Array.isArray(loaded)) ?
         loaded :
         {};
     const { name, _source, ...caseBody } = dataset;
     fileObj[name] = { ...fileObj[name], ...caseBody };
-    await writeFile(filePath, yaml.dump(fileObj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
+    await writeFile(filePath, stringifyYaml(fileObj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
 }
 export async function listDatasets(workflowName, basePath) {
     const dir = await resolveDatasetsDir(workflowName, basePath);

package/dist/services/datasets.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { mkdtemp, rm, writeFile, readFile, mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import yaml from 'js-yaml';
+import { load as parseYaml, dump as stringifyYaml } from 'js-yaml';
 import { readDatasetFile, readAllDatasets, writeDataset, listDatasets, resolveDefaultDatasetsDir, datasetFilePath } from './datasets.js';
 import * as catalog from '#api/workflow_catalog.js';
 vi.mock('#api/workflow_catalog.js', () => ({
@@ -20,7 +20,7 @@ afterEach(async () => {
     await rm(ctx.tmpDir, { recursive: true, force: true });
 });
 function writeYaml(filePath, obj) {
-    return writeFile(filePath, yaml.dump(obj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
+    return writeFile(filePath, stringifyYaml(obj, { lineWidth: 120, noRefs: true, sortKeys: false }), 'utf-8');
 }
 // ---------------------------------------------------------------------------
 // readDatasetFile
@@ -142,7 +142,7 @@ describe('writeDataset', () => {
         const filePath = join(ctx.tmpDir, 'cases.yml');
         const dataset = { name: 'new_case', input: { q: 'hello' } };
         await writeDataset(dataset, filePath);
-        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const raw = parseYaml(await readFile(filePath, 'utf-8'));
         expect(raw).toHaveProperty('new_case');
         expect(raw.new_case.input).toEqual({ q: 'hello' });
         expect(raw.new_case).not.toHaveProperty('name');
@@ -151,7 +151,7 @@ describe('writeDataset', () => {
         const filePath = join(ctx.tmpDir, 'cases.yml');
         const dataset = { name: 'my_case', input: { q: 'x' }, _source: '/some/path.yml' };
         await writeDataset(dataset, filePath);
-        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const raw = parseYaml(await readFile(filePath, 'utf-8'));
         expect(raw.my_case).not.toHaveProperty('_source');
     });
     it('updates only the target case, leaving other cases untouched', async () => {
@@ -161,7 +161,7 @@ describe('writeDataset', () => {
             case_b: { input: { x: 2 }, ground_truth: { expected: 2 } }
         });
         await writeDataset({ name: 'case_a', input: { x: 1 }, last_output: { output: { result: 1 }, date: '2026-01-01T00:00:00.000Z' } }, filePath);
-        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const raw = parseYaml(await readFile(filePath, 'utf-8'));
         expect(raw).toHaveProperty('case_b');
         expect(raw.case_b.ground_truth).toEqual({ expected: 2 });
     });
@@ -175,7 +175,7 @@ describe('writeDataset', () => {
             name: 'my_case', input: { q: 'hello' },
             last_eval: { output: { datasetName: 'my_case', verdict: 'pass', evaluators: [] }, date: '2026-01-01T00:01:00.000Z' }
         }, filePath);
-        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const raw = parseYaml(await readFile(filePath, 'utf-8'));
         const caseObj = raw.my_case;
         expect(caseObj).toHaveProperty('last_output');
         expect(caseObj).toHaveProperty('last_eval');
@@ -184,14 +184,14 @@ describe('writeDataset', () => {
     it('creates parent directories if they do not exist', async () => {
         const filePath = join(ctx.tmpDir, 'deep', 'nested', 'cases.yml');
         await writeDataset({ name: 'my_case', input: { q: 'x' } }, filePath);
-        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const raw = parseYaml(await readFile(filePath, 'utf-8'));
         expect(raw).toHaveProperty('my_case');
     });
     it('recovers gracefully when existing file contains non-object YAML', async () => {
         const filePath = join(ctx.tmpDir, 'cases.yml');
         await writeFile(filePath, 'just a string', 'utf-8');
         await writeDataset({ name: 'my_case', input: { q: 'x' } }, filePath);
-        const raw = yaml.load(await readFile(filePath, 'utf-8'));
+        const raw = parseYaml(await readFile(filePath, 'utf-8'));
         expect(raw).toHaveProperty('my_case');
     });
 });

package/dist/services/fix_package.d.ts

@@ -14,7 +14,7 @@ export interface ScriptToReplace {
     after: string;
 }
 /**
- * Plan for aligning `scripts` with the scaffold template (reads only; no write until apply).
+ * Plan for aligning `scripts` with the scaffold template and dropping stale hook files (reads only; no write until apply).
  */
 export interface FixPlan {
     packageJsonPath: string;
@@ -23,6 +23,7 @@ export interface FixPlan {
     scriptsToRemove: ScriptToRemove[];
     scriptsToReplace: ScriptToReplace[];
     scriptsToAdd: ScriptToAdd[];
+    hookFilesToRemove: string[];
 }
 /**
  * Computes the package.json rewrite without writing. Use with {@link applyFix}.

package/dist/services/fix_package.js

@@ -6,6 +6,8 @@ const packageJson = 'package.json';
 const templateRelativePath = path.join('templates', 'project', 'package.json.template');
 /** Legacy script names from older versions of the project */
 export const legacyScripts = ['dev'];
+/** Hook files from the @outputai/credentials package, which was folded into @outputai/core */
+const credentialsHookFilePattern = /@outputai[\\/]credentials([\\/]|$)/;
 function getTemplatesPackageJsonPath() {
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
@@ -34,6 +36,16 @@ function parsePackageJsonObject(raw, packagePath) {
         throw new Error(`File ${packagePath} is not a valid JSON.`, { cause: error });
     }
 }
+function removeCredentialsHookFiles(pkg) {
+    const section = pkg.outputai;
+    if (typeof section !== 'object' || section === null || !Array.isArray(section.hookFiles)) {
+        return [];
+    }
+    const hookFiles = section.hookFiles;
+    const removed = hookFiles.filter((file) => typeof file === 'string' && credentialsHookFilePattern.test(file));
+    section.hookFiles = hookFiles.filter(file => !removed.includes(file));
+    return removed;
+}
 function parseTemplatePackageJson(processed) {
     try {
         return JSON.parse(processed);
@@ -83,6 +95,7 @@ export function planFix(projectRoot) {
         scripts[key] = after;
     }
     pkg.scripts = scripts;
+    const hookFilesToRemove = removeCredentialsHookFiles(pkg);
     const packageJsonUpdatedContent = `${JSON.stringify(pkg, null, 2)}\n`;
     const hasChanges = packageJsonUpdatedContent !== raw;
     return {
@@ -91,7 +104,8 @@ export function planFix(projectRoot) {
         hasChanges,
         scriptsToRemove,
         scriptsToReplace,
-        scriptsToAdd
+        scriptsToAdd,
+        hookFilesToRemove
     };
 }
 /**

package/dist/services/fix_package.spec.js

@@ -52,6 +52,38 @@ describe('fix package', () => {
             'output:worker:watch'
         ].sort());
     });
+    it('should remove hook files pointing to @outputai/credentials and keep the others', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fix-test-'));
+        const pkg = {
+            name: 'my-proj',
+            outputai: {
+                hookFiles: [
+                    'dist/hooks/cost_hooks.js',
+                    'node_modules/@outputai/credentials/dist/hooks.js',
+                    'dist/hooks/register_credentials.js'
+                ]
+            }
+        };
+        await fs.writeFile(path.join(tmpDir, 'package.json'), JSON.stringify(pkg, null, 2), 'utf-8');
+        const plan = planFix(tmpDir);
+        expect(plan.hookFilesToRemove).toEqual(['node_modules/@outputai/credentials/dist/hooks.js']);
+        applyFix(plan);
+        const next = JSON.parse(await fs.readFile(path.join(tmpDir, 'package.json'), 'utf-8'));
+        expect(next.outputai.hookFiles).toEqual(['dist/hooks/cost_hooks.js', 'dist/hooks/register_credentials.js']);
+    });
+    it('should leave outputai untouched when hookFiles is missing or not an array', async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fix-test-'));
+        const missing = { name: 'my-proj', outputai: {} };
+        await fs.writeFile(path.join(tmpDir, 'package.json'), JSON.stringify(missing, null, 2), 'utf-8');
+        const missingPlan = planFix(tmpDir);
+        expect(missingPlan.hookFilesToRemove).toEqual([]);
+        expect(JSON.parse(missingPlan.packageJsonUpdatedContent).outputai).toEqual({});
+        const malformed = { name: 'my-proj', outputai: { hookFiles: 'node_modules/@outputai/credentials/dist/hooks.js' } };
+        await fs.writeFile(path.join(tmpDir, 'package.json'), JSON.stringify(malformed, null, 2), 'utf-8');
+        const malformedPlan = planFix(tmpDir);
+        expect(malformedPlan.hookFilesToRemove).toEqual([]);
+        expect(JSON.parse(malformedPlan.packageJsonUpdatedContent).outputai).toEqual(malformed.outputai);
+    });
     it('should throw when package.json is missing', async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fix-test-'));
         expect(() => planFix(tmpDir)).toThrow(/No package\.json found/);

package/dist/services/messages.js

@@ -168,7 +168,7 @@ export const getProjectSuccessMessage = (folderName, installSuccess, credentials
         steps.push({
             step: 'Add your API credentials',
             command: 'npx output credentials edit',
-            note: 'Learn more: https://docs.output.ai/packages/credentials'
+            note: 'Learn more: https://docs.output.ai/packages/core/credentials'
         });
     }
     steps.push({

package/dist/templates/project/package.json.template

@@ -23,8 +23,5 @@
   },
   "engines": {
     "node": ">=24.3.0"
-  },
-  "outputai": {
-    "hookFiles": ["node_modules/@outputai/credentials/dist/hooks.js"]
   }
 }

package/dist/utils/credentials_loader.js

@@ -1,4 +1,4 @@
-import { InvalidCredentialsKeyError, MalformedCredentialsKeyError, MissingKeyError, resolveCredentialRefs } from '@outputai/credentials';
+import { InvalidCredentialsKeyError, MalformedCredentialsKeyError, MissingKeyError, resolveCredentialRefs } from '@outputai/core/credentials';
 const isCredentialsConfigError = (error) => error instanceof MissingKeyError ||
     error instanceof InvalidCredentialsKeyError ||
     error instanceof MalformedCredentialsKeyError;

package/dist/utils/credentials_loader.spec.js

@@ -1,8 +1,8 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as credentials from '@outputai/credentials';
+import * as credentials from '@outputai/core/credentials';
 import { loadCredentialRefs } from './credentials_loader.js';
-vi.mock('@outputai/credentials', async () => {
-    const actual = await vi.importActual('@outputai/credentials');
+vi.mock('@outputai/core/credentials', async () => {
+    const actual = await vi.importActual('@outputai/core/credentials');
     return {
         ...actual,
         resolveCredentialRefs: vi.fn()

package/dist/utils/search_attributes_flag.d.ts

@@ -0,0 +1,2 @@
+import type { PostWorkflowRunBodySearchAttributes } from '#api/generated/api.js';
+export declare const parseSearchAttributesFlag: (flag?: string) => PostWorkflowRunBodySearchAttributes | undefined;

package/dist/utils/search_attributes_flag.js

@@ -0,0 +1,22 @@
+import { parseInputFlag } from '#utils/input_parser.js';
+const isScalar = (value) => ['string', 'number', 'boolean'].includes(typeof value);
+const isValidValue = (value) => isScalar(value) || (Array.isArray(value) && value.every(v => typeof v === 'string'));
+const validate = (parsed) => {
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('--search-attributes must be a JSON object, e.g. \'{"ClientId":"acme"}\'');
+    }
+    const invalid = Object.entries(parsed).find(([, value]) => !isValidValue(value));
+    if (invalid) {
+        throw new Error(`--search-attributes value for "${invalid[0]}" must be a string, number, boolean, or array of strings`);
+    }
+    return parsed;
+};
+const parse = (flag) => {
+    try {
+        return parseInputFlag(flag);
+    }
+    catch (error) {
+        throw new Error(`--search-attributes: ${error.message}`);
+    }
+};
+export const parseSearchAttributesFlag = (flag) => (flag === undefined ? undefined : validate(parse(flag)));

package/dist/utils/search_attributes_flag.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/search_attributes_flag.spec.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { parseSearchAttributesFlag } from './search_attributes_flag.js';
+describe('parseSearchAttributesFlag', () => {
+    it('returns undefined when the flag is not set', () => {
+        expect(parseSearchAttributesFlag(undefined)).toBeUndefined();
+    });
+    it('parses a JSON object of scalars and string arrays', () => {
+        const flag = '{"ClientId":"acme","Priority":5,"Active":true,"Tags":["sales","emea"]}';
+        expect(parseSearchAttributesFlag(flag)).toEqual({
+            ClientId: 'acme',
+            Priority: 5,
+            Active: true,
+            Tags: ['sales', 'emea']
+        });
+    });
+    it('accepts an empty object', () => {
+        expect(parseSearchAttributesFlag('{}')).toEqual({});
+    });
+    it.each([
+        ['an array', '["acme"]'],
+        ['a string', '"acme"'],
+        ['null', 'null'],
+        ['a number', '5']
+    ])('rejects %s', (_, flag) => {
+        expect(() => parseSearchAttributesFlag(flag)).toThrow('--search-attributes must be a JSON object');
+    });
+    it.each([
+        ['an object value', '{"ClientId":{"id":1}}'],
+        ['a null value', '{"ClientId":null}'],
+        ['a number array', '{"Tags":[1,2]}'],
+        ['a mixed array', '{"Tags":["a",1]}']
+    ])('rejects %s', (_, flag) => {
+        expect(() => parseSearchAttributesFlag(flag)).toThrow('must be a string, number, boolean, or array of strings');
+    });
+    it('reports invalid JSON', () => {
+        expect(() => parseSearchAttributesFlag('{not json')).toThrow(/^--search-attributes: (Invalid JSON input|Input file not found)/);
+    });
+});

package/oclif.manifest.json

@@ -3,7 +3,7 @@
     "fix": {
       "aliases": [],
       "args": {},
-      "description": "Fix Output scripts in the package.json (reset overwrites, add missing and remove deprecated)",
+      "description": "Fix Output scripts in the package.json (reset overwrites, add missing and remove deprecated) and remove stale hook files",
       "examples": [
         "<%= config.bin %> <%= command.id %>"
       ],
@@ -1165,7 +1165,8 @@
         "<%= config.bin %> <%= command.id %> simple my_scenario --json",
         "<%= config.bin %> <%= command.id %> simple --input '{\"values\":[1,2,3]}'",
         "<%= config.bin %> <%= command.id %> simple --input input.json",
-        "<%= config.bin %> <%= command.id %> simple --input '{\"key\":\"value\"}' --catalog my-catalog"
+        "<%= config.bin %> <%= command.id %> simple --input '{\"key\":\"value\"}' --catalog my-catalog",
+        "<%= config.bin %> <%= command.id %> simple basic_input --search-attributes '{\"ClientId\":\"acme\"}'"
       ],
       "flags": {
         "json": {
@@ -1199,6 +1200,15 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "search-attributes": {
+          "char": "a",
+          "description": "Temporal search attributes as a JSON object or file path, e.g. {\"ClientId\":\"acme\"}. Each attribute must be registered on the namespace",
+          "name": "search-attributes",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
         }
       },
       "hasDynamicHelp": false,
@@ -1238,6 +1248,7 @@
         "<%= config.bin %> <%= command.id %> simple --input input.json",
         "<%= config.bin %> <%= command.id %> simple --input input.json --monitor",
         "<%= config.bin %> <%= command.id %> simple --input '{\"key\":\"value\"}' --catalog my-catalog",
+        "<%= config.bin %> <%= command.id %> simple basic_input --search-attributes '{\"ClientId\":\"acme\"}'",
         "<%= config.bin %> <%= command.id %> simple --json"
       ],
       "flags": {
@@ -1273,6 +1284,15 @@
           "multiple": false,
           "type": "option"
         },
+        "search-attributes": {
+          "char": "a",
+          "description": "Temporal search attributes as a JSON object or file path, e.g. {\"ClientId\":\"acme\"}. Each attribute must be registered on the namespace",
+          "name": "search-attributes",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "monitor": {
           "char": "m",
           "description": "After starting, attach and stream status updates until the workflow ends (Ctrl+C detaches; the workflow keeps running). Cannot be combined with --json",
@@ -1752,5 +1772,5 @@
       ]
     }
   },
-  "version": "0.14.1-next.bd031f8.0"
+  "version": "0.14.1-next.e9dfa49.0"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/cli",
-  "version": "0.14.1-next.bd031f8.0",
+  "version": "0.14.1-next.e9dfa49.0",
   "description": "CLI for Output.ai workflow generation",
   "type": "module",
   "main": "dist/index.js",
@@ -17,37 +17,37 @@
     "output": "./bin/run.js"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.92",
+    "@anthropic-ai/claude-agent-sdk": "0.3.281",
     "@hackylabs/deep-redact": "3.0.5",
-    "@inquirer/prompts": "8.4.2",
+    "@inquirer/prompts": "8.7.2",
     "@oclif/core": "4.10.6",
     "@oclif/plugin-help": "6.2.45",
     "change-case": "5.4.4",
     "cli-progress": "3.12.0",
     "cli-table3": "0.6.5",
-    "date-fns": "4.1.0",
+    "date-fns": "4.4.0",
     "debug": "4.4.3",
     "handlebars": "4.7.9",
     "ink": "7.0.1",
     "ink-spinner": "5.0.0",
-    "js-yaml": "4.3.2",
-    "json-schema-library": "11.4.0",
+    "js-yaml": "5.4.2",
+    "json-schema-library": "11.6.2",
     "ky": "2.0.2",
-    "react": "19.2.5",
-    "semver": "7.7.4",
-    "undici": "8.9.0",
-    "@outputai/credentials": "0.14.1-next.bd031f8.0",
-    "@outputai/llm": "0.14.1-next.bd031f8.0",
-    "@outputai/evals": "0.14.1-next.bd031f8.0"
+    "react": "19.3.0",
+    "semver": "7.8.5",
+    "undici": "8.11.0",
+    "@outputai/core": "0.14.1-next.e9dfa49.0",
+    "@outputai/llm": "0.14.1-next.e9dfa49.0",
+    "@outputai/evals": "0.14.1-next.e9dfa49.0"
   },
   "devDependencies": {
     "@types/cli-progress": "3.11.6",
     "@types/debug": "4.1.13",
     "@types/js-yaml": "4.0.9",
-    "@types/react": "19.2.14",
-    "@types/semver": "7.7.1",
+    "@types/react": "19.3.0",
+    "@types/semver": "7.8.0",
     "oclif": "4.23.10",
-    "orval": "8.24.0"
+    "orval": "8.37.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {