@you-agent-factory/client 0.0.2 → 0.0.7

package/dist/generated/openapi.d.ts

@@ -145,6 +145,7 @@ export interface paths {
          *     Reconnect cursors: pass after_event_id or after_sequence to receive only events recorded after the acknowledged point. When both are present, after_event_id wins. For session-scoped streams, after_sequence prefers FactoryEvent.context.sessionSequence when that field is present; otherwise it falls back to FactoryEvent.context.sequence. Omitting both cursors starts replay from the beginning of the session's currently retained history.
          *     Replay bounds: live sessions replay only events retained for the current stream generation of the targeted Factory Session. Durable execution session identifiers replay persisted canonical records for that session without crossing into another session. Cursors that no longer match the retained history boundary return typed invalid-cursor handling (400 on SSE open, cursor_stale on JSON reconnect probe) rather than silently skipping events.
          *     Identity handshake before reconnect: compare the response headers X-Factory-Session-Backend-Scope-Id, X-Factory-Session-Logical-Session-Key-Id, X-Factory-Session-Factory-Session-Id, and X-Factory-Session-Stream-Generation-Id with the latest sync-preflight or session-read identity set before reusing a persisted reconnect cursor or stream-derived cache. A changed streamGenerationId means the current stream generation invalidates prior cursors even when factorySessionId is unchanged.
+         *     Bounded retained-history reads: X-Factory-Session-Retained-Event-Count reports exactly how many leading text/event-stream data frames make up the already-committed retained-history prefix, captured at subscribe time. Clients that need a point-in-time snapshot of committed history can read exactly this many records and stop, instead of inferring completion from stream quiescence.
          *     Keepalives: successful SSE responses use Connection keep-alive. Idle periods may occur while the Factory Session is waiting for new canonical events; clients must treat these as normal waiting state rather than terminal stream completion unless the HTTP connection closes.
          *     Expired-cursor recovery: when Accept includes application/json, the same route acts as a reconnect probe and returns FactorySessionEventStreamRecovery instead of opening Server-Sent Events. cursor_stale outcomes tell clients to retry with omitAfterEventId and omitAfterSequence set so the next open omits stale cursors. UNKNOWN_SESSION means the selector does not resolve to a live or durable session and never falls back to the default session.
          *     Unknown session identifiers return NOT_FOUND instead of falling back to the default session.
@@ -810,6 +811,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/packaged-factories": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List built-in packaged factories
+         * @description Returns the backend-owned built-in factory catalog, including the selected artifacts the dashboard displays. The dashboard must consume this API rather than importing the publication package.
+         */
+        get: operations["listPackagedFactories"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -2557,6 +2578,28 @@ export interface components {
          * @enum {string}
          */
         FactorySessionLifecycleControlKind: FactorySessionLifecycleControlKind;
+        PackagedFactoryCatalogResponse: {
+            /** @description Built-in Factory definitions in stable lexical name order. */
+            factories: components["schemas"]["PackagedFactoryCatalogEntry"][];
+        };
+        PackagedFactoryCatalogEntry: {
+            /** @description Public built-in Factory name, such as '@you/goal'. */
+            name: string;
+            /** @description Stable Factory project identifier. */
+            project: string;
+            /** @description URL-safe Factory catalog identity. */
+            slug: string;
+            /** @description Localized customer-facing explanation of what this packaged Factory does. */
+            description: components["schemas"]["NameValue"];
+            /** @description Representative runnable invocations published by this packaged Factory. */
+            examples: components["schemas"]["FactoryInvocationExample"][];
+            /** @description Canonical Factory JSON artifact. */
+            json: {
+                [key: string]: unknown;
+            };
+            /** @description Equivalent Factory YAML artifact. */
+            yaml: string;
+        };
         /**
          * @description Typed lifecycle-control outcome. ACCEPTED means the control request was accepted and may complete asynchronously. NO_OP means the session was already in the requested end state. INVALID_STATE means the current session state does not allow the requested control. TERMINAL_SESSION means the session is already terminal and cannot accept the requested control. CONFLICT means another in-flight or incompatible control prevents the request.
          * @enum {string}
@@ -2816,6 +2859,24 @@ export interface components {
         };
         /** @description Customer-facing identifier for one stored named factory. `GET /factory-sessions/~default/factory` may also return the reserved `UNDEFINED` identifier when the active runtime is still the default root factory and no durable current-factory pointer exists. Semantic validation failures return `INVALID_FACTORY_NAME`, including attempts to activate a named factory with the reserved identifier. */
         FactoryName: string;
+        /** @description A customer-facing value with a required base fallback and optional exact locale overrides. Locale tags must use their canonical BCP 47 spelling. */
+        NameValue: {
+            /**
+             * @description Discriminator for localized customer-facing metadata.
+             * @enum {string}
+             */
+            type: NameValueType;
+            /** @description Required base value returned when no exact locale override exists. */
+            value: string;
+            /** @description Canonical BCP 47 locales for which the base value was authored. */
+            locales?: string[];
+            /** @description Exact canonical BCP 47 locale tags mapped to localized overrides. */
+            values?: {
+                [key: string]: string;
+            };
+            /** @description Optional stable metadata identifier; consumers must not render it as display copy. */
+            id?: string;
+        };
         /** @description Additive dashboard read-model contract slice that publishes workstation-request projections keyed by dispatch ID without reintroducing removed `/dashboard` endpoints. */
         FactoryWorldWorkstationRequestProjectionSlice: {
             workstationRequestsByDispatchId?: {
@@ -3019,7 +3080,7 @@ export interface components {
             id: string;
             type: components["schemas"]["FactoryEventType"];
             context: components["schemas"]["FactoryEventContext"];
-            payload: components["schemas"]["RunRequestEventPayload"] | components["schemas"]["InitialStructureRequestEventPayload"] | components["schemas"]["FactoryChangeEventPayload"] | components["schemas"]["WorkRequestEventPayload"] | components["schemas"]["RelationshipChangeRequestEventPayload"] | components["schemas"]["DispatchRequestEventPayload"] | components["schemas"]["ModelRequestEventPayload"] | components["schemas"]["ModelResponseEventPayload"] | components["schemas"]["InferenceRequestEventPayload"] | components["schemas"]["InferenceResponseEventPayload"] | components["schemas"]["ScriptRequestEventPayload"] | components["schemas"]["ScriptResponseEventPayload"] | components["schemas"]["AgentRunResponseEventPayload"] | components["schemas"]["DispatchResponseEventPayload"] | components["schemas"]["WorkStateChangeEventPayload"] | components["schemas"]["FactoryStateResponseEventPayload"] | components["schemas"]["RunResponseEventPayload"] | components["schemas"]["SessionStartedEventPayload"] | components["schemas"]["SessionPausedEventPayload"] | components["schemas"]["SessionResumedEventPayload"] | components["schemas"]["SessionResultUpdatedEventPayload"] | components["schemas"]["SessionCompletedEventPayload"] | components["schemas"]["SessionLifecycleControlEventPayload"] | components["schemas"]["OrchestratorPhaseChangedEventPayload"] | components["schemas"]["OrchestratorCheckpointWrittenEventPayload"] | components["schemas"]["DispatchQueuedEventPayload"] | components["schemas"]["DispatchInterruptedEventPayload"] | components["schemas"]["DispatchReconciledEventPayload"] | components["schemas"]["JavaScriptCheckpointRefEventPayload"] | components["schemas"]["JavaScriptPhaseChangeEventPayload"] | components["schemas"]["ArtifactCreatedEventPayload"];
+            payload: components["schemas"]["RunRequestEventPayload"] | components["schemas"]["InitialStructureRequestEventPayload"] | components["schemas"]["FactoryChangeEventPayload"] | components["schemas"]["WorkRequestEventPayload"] | components["schemas"]["RelationshipChangeRequestEventPayload"] | components["schemas"]["DispatchRequestEventPayload"] | components["schemas"]["DispatchWorkerSessionAssociationEventPayload"] | components["schemas"]["ModelRequestEventPayload"] | components["schemas"]["ModelResponseEventPayload"] | components["schemas"]["InferenceRequestEventPayload"] | components["schemas"]["InferenceResponseEventPayload"] | components["schemas"]["ScriptRequestEventPayload"] | components["schemas"]["ScriptResponseEventPayload"] | components["schemas"]["AgentRunResponseEventPayload"] | components["schemas"]["DispatchResponseEventPayload"] | components["schemas"]["WorkStateChangeEventPayload"] | components["schemas"]["FactoryStateResponseEventPayload"] | components["schemas"]["RunResponseEventPayload"] | components["schemas"]["SessionStartedEventPayload"] | components["schemas"]["SessionPausedEventPayload"] | components["schemas"]["SessionResumedEventPayload"] | components["schemas"]["SessionResultUpdatedEventPayload"] | components["schemas"]["SessionCompletedEventPayload"] | components["schemas"]["SessionLifecycleControlEventPayload"] | components["schemas"]["OrchestratorPhaseChangedEventPayload"] | components["schemas"]["OrchestratorCheckpointWrittenEventPayload"] | components["schemas"]["DispatchQueuedEventPayload"] | components["schemas"]["DispatchInterruptedEventPayload"] | components["schemas"]["DispatchReconciledEventPayload"] | components["schemas"]["JavaScriptCheckpointRefEventPayload"] | components["schemas"]["JavaScriptPhaseChangeEventPayload"] | components["schemas"]["ArtifactCreatedEventPayload"];
         };
         /** @description Chapter-free recording of canonical Factory Events for exactly one Factory Session. Events remain in their recorded canonical order. */
         FactoryRecording: {
@@ -3141,6 +3202,11 @@ export interface components {
             resources?: components["schemas"]["Resource"][];
             metadata?: components["schemas"]["DispatchRequestEventMetadata"];
         };
+        /** @description Canonical association between one Factory dispatch and the Worker Session allocated to execute it. Dispatch identity remains authoritative in FactoryEvent.context.dispatchId and is not repeated in this payload. */
+        DispatchWorkerSessionAssociationEventPayload: {
+            /** @description Non-empty Worker Session identity allocated for the dispatch. */
+            workerSessionId: string;
+        };
         /** @description Request details captured immediately before a model-backed worker invocation enters resource, load, and execution boundaries. FactoryEvent.context owns dispatch, request, trace, and work identity, and the matching dispatch-request event owns the transition identifier. */
         ModelRequestEventPayload: {
             /** @description Stable identifier correlating this model execution request with its response. */
@@ -3208,6 +3274,7 @@ export interface components {
             outputPreview?: string;
             outputContent?: components["schemas"]["WorkContent"];
             diagnostics?: components["schemas"]["SafeWorkDiagnostics"];
+            providerSession?: components["schemas"]["ProviderSessionMetadata"];
             failureDetail?: components["schemas"]["FailureDetail"];
         };
         /** @description Request details captured immediately before a model-worker provider attempt is invoked. FactoryEvent.context owns dispatch, request, trace, and work identity, and the matching dispatch-request event owns the transition identifier. Prompt content is intentionally present and should be treated as sensitive in recordings and diagnostics. */
@@ -3926,6 +3993,8 @@ export interface components {
         /** @description Top-level factory.json contract. Declare the work types, resources, portability resources, workers, and workstations that make up one authored factory here. Guarded loop breakers should be authored as guarded LOGICAL_MOVE workstations using VISIT_COUNT guards instead of a top-level exhaustion-rules field. */
         Factory: {
             name: components["schemas"]["FactoryName"];
+            /** @description Optional localized customer-facing explanation of this Factory. */
+            description?: components["schemas"]["NameValue"];
             /** @description Factory identifier used as the factory-level template context fallback. */
             id?: string;
             /** @description Default runner selection for the factory when a workstation does not declare its own runner override. */
@@ -3946,6 +4015,8 @@ export interface components {
             invocationReturn?: components["schemas"]["InvocationReturn"];
             /** @description Optional canonical callable argument contract shared by CLI, API, dashboard, docs, and packaged factories. When omitted, callers use the factory's compatibility invocation behavior. */
             invocationSignature?: components["schemas"]["FactoryInvocationSignature"];
+            /** @description Ordered runnable invocation examples. Canonical Factory documents write examples here; legacy invocationSignature.examples are accepted only by the Factory input compatibility mapper. */
+            examples?: components["schemas"]["FactoryInvocationExample"][];
             /** @description Root-level guards that apply across the factory instead of one specific workstation or input. */
             guards?: components["schemas"]["FactoryGuard"][];
             /** @description Customer-authored work item categories and the lifecycle states each one can occupy. */
@@ -4021,8 +4092,6 @@ export interface components {
             unknownNamedArgumentPolicy?: components["schemas"]["FactoryInvocationUnknownNamedArgumentPolicy"];
             /** @description Optional customer-facing hint for the factory's primary output shape. */
             outputContract?: components["schemas"]["FactoryInvocationOutputContract"];
-            /** @description Example invocations rendered in docs, help, and inspection surfaces. */
-            examples?: components["schemas"]["FactoryInvocationExample"][];
         };
         /** @description One canonical invocation parameter declared on a factory. */
         FactoryInvocationParameter: {
@@ -4100,12 +4169,14 @@ export interface components {
         FactoryInvocationExample: {
             /** @description Stable example name. */
             name: string;
-            /** @description Customer-facing explanation of what the example does. */
-            description?: string;
-            /** @description CLI-style argument vector rendered after factory selection. */
-            argv?: string[];
-            /** @description Example stdin payload when the signature routes stdin into one parameter. */
-            stdin?: string;
+            /** @description Localized customer-facing explanation of what the example does. */
+            description: components["schemas"]["NameValue"];
+            /** @description Structured invocation arguments; values are never parsed or executed while loading the Factory. */
+            args: components["schemas"]["FactoryInvocationArguments"];
+        };
+        /** @description Structured Factory invocation arguments keyed by parameter name, external name, or alias. Each value is either one string or an ordered array of strings. */
+        FactoryInvocationArguments: {
+            [key: string]: string | string[];
         };
         /** @description Factory-authored policy for selecting the primary result returned by CLI and API invocations. When omitted from a Factory, runtimes use the documented SUBMITTED_WORK_TERMINAL fallback. */
         InvocationReturn: {
@@ -4128,7 +4199,7 @@ export interface components {
             /** @description Factory-level guard condition to evaluate before dispatch-ready transitions can proceed. */
             type: components["schemas"]["FactoryGuardType"];
             /** @description Provider whose inference-throttle history controls this factory-level guard. */
-            modelProvider: components["schemas"]["WorkerModelProvider"];
+            modelProvider: components["schemas"]["ProviderIdentity"];
             /** @description Optional model name to scope throttling more narrowly than the provider-level window. */
             model?: string;
             /** @description Duration string that controls how long the factory should keep re-checking throttle history before allowing the lane again. */
@@ -4192,6 +4263,8 @@ export interface components {
             id?: string;
             /** @description Customer-authored work type name referenced by workstation inputs, outputs, and submitted work. */
             name: string;
+            /** @description Optional localized customer-facing explanation of this work type. */
+            description?: components["schemas"]["NameValue"];
             /** @description Lifecycle states available for work items of this type. */
             states: components["schemas"]["WorkState"][];
             /** @description Optional CLI routing markers for this work type. Factories used with you run --factory must declare handlingBehavior DEFAULT on exactly one work type. */
@@ -4241,17 +4314,20 @@ export interface components {
             id?: string;
             /** @description Worker name referenced by Workstation.worker. */
             name: string;
+            /** @description Optional localized customer-facing explanation of this worker. */
+            description?: components["schemas"]["NameValue"];
             /** @description Worker implementation family to instantiate for this definition. */
             type?: components["schemas"]["WorkerType"];
             /** @description Built-in hosted provider identity when this worker uses repository-owned hosted execution. */
             provider?: components["schemas"]["HostedWorkerProvider"];
             /** @description Model identifier to request from the configured model provider when this worker uses model execution. */
             model?: string;
-            /** @description Canonical model-provider identifier used for model routing and provider diagnostics. Current public built-in values are `CLAUDE` and `CODEX`; the runtime maps them onto the underlying provider command IDs. */
-            modelProvider?: components["schemas"]["WorkerModelProvider"];
+            /** @description Canonical provider identity used for model routing and provider diagnostics, or an exact invocation-parameter placeholder such as `${modelProvider}`. For `executorProvider: ACP`, this names the configured ACP integration, such as `cursor-acp`. Extension identities use lowercase standardized syntax; built-in values such as `CLAUDE` and `CODEX` remain compatibility conveniences. */
+            modelProvider?: components["schemas"]["ProviderIdentity"] | string;
+            reasoningEffort?: components["schemas"]["ReasoningEffort"];
             /** @description Provider locality for this model capability declaration. Use `LOCAL` for embedded or host-managed inference and `CLOUD` for remote provider execution. */
             modelLocality?: components["schemas"]["WorkerModelLocality"];
-            /** @description Canonical executor adapter identifier used to select the worker execution provider or wrapper. The current public built-in value is `SCRIPT_WRAP`. */
+            /** @description Execution mechanism. Use `ACP` for ACP-backed workers and put the configured integration identity (for example `cursor-acp`) in modelProvider. `SCRIPT_WRAP` remains the command-wrapper compatibility value; legacy named executor identities remain accepted during migration. */
             executorProvider?: components["schemas"]["WorkerProvider"];
             /** @description Provider-agnostic model operations that this worker can execute, including named input and output slots. */
             operations?: components["schemas"]["ModelOperation"][];
@@ -4267,8 +4343,6 @@ export interface components {
             stopToken?: string;
             /** @description When true, bypasses permission checks for providers that support permission gating. */
             skipPermissions?: boolean;
-            /** @description Optional OpenCode agent profile name for model workers that dispatch through the OpenCode runner. When set, OpenCode dispatches invoke `opencode run --agent <name>`. Discover agent names with `opencode agent list` (see https://opencode.ai/docs/cli/). */
-            openCodeAgent?: string;
             /** @description Hosted-worker authentication contract. V1 hosted workers accept only auth.secretRef. */
             auth?: components["schemas"]["HostedWorkerAuth"];
             /** @description Provider-specific configuration for the built-in hosted LINEAR worker. */
@@ -4294,20 +4368,156 @@ export interface components {
          */
         WorkerType: WorkerType;
         /**
-         * @description Canonical model-provider identifiers supported by model workers in factory config.
+         * @description Built-in model-provider constants retained as generated-client conveniences. Authored modelProvider fields use the open ProviderIdentity contract, so this list is not an exhaustive provider inventory.
          * @enum {string}
          */
         WorkerModelProvider: WorkerModelProvider;
+        /** @description Open provider identity used by authored modelProvider fields. Extension identities use lowercase letters and digits separated by dots or hyphens. Built-in identities and documented legacy aliases remain accepted compatibility spellings. For example, `customer.provider` is a valid extension identity. */
+        ProviderIdentity: string;
+        /** @description Versioned public collection of provider manifests. */
+        ProviderCatalog: {
+            /**
+             * @description Provider Catalog document format version.
+             * @enum {string}
+             */
+            formatVersion: ProviderCatalogFormatVersion;
+            /**
+             * Format: uri
+             * @description Immutable JSON Schema identifier used to validate every provider entry.
+             * @enum {string}
+             */
+            providerSchema: ProviderCatalogProviderSchema;
+            /** @description Optional source-revision provenance supplied by a publication staging process. */
+            publicationProvenance?: {
+                /**
+                 * Format: uri
+                 * @description Public source repository from which the catalog was published.
+                 */
+                sourceRepository: string;
+                /** @description Full immutable Git commit identifying the published source tree. */
+                sourceCommit: string;
+            };
+            /** @description Provider manifests in canonical provider-ID order. */
+            providers: components["schemas"]["ProviderManifest"][];
+        };
+        /** @description Public, data-only metadata for one model-provider integration. A manifest describes evidenced maximum behavior and publication posture; it never reports current-machine installation, authentication, readiness, pricing, or runtime registration. */
+        ProviderManifest: {
+            /** @description Stable canonical lowercase provider identifier. */
+            id: string;
+            /** @description Alternate lowercase identifiers; aliases must not equal or shadow any catalog ID or alias. */
+            aliases: string[];
+            /** @description Localizable customer-facing provider name. */
+            displayName: components["schemas"]["NameValue"];
+            /** @description Localizable customer-facing provider summary. */
+            description: components["schemas"]["NameValue"];
+            /** @description Stable public documentation links for this provider. */
+            documentation: components["schemas"]["ProviderDocumentationLink"][];
+            technicalSupportLevel: components["schemas"]["ProviderTechnicalSupportLevel"];
+            implementationAvailability: components["schemas"]["ProviderImplementationAvailability"];
+            maximumExecutionCapabilities: components["schemas"]["ProviderExecutionCapabilities"];
+            maximumResponseFidelityCapabilities: components["schemas"]["ProviderResponseFidelityCapabilities"];
+            discovery: components["schemas"]["ProviderDiscoveryPrerequisites"];
+            deprecation?: components["schemas"]["ProviderDeprecation"];
+        };
+        /**
+         * @description Maintainer-verified technical support posture for a provider integration. This value does not describe whether the provider is installed or ready on the current machine.
+         * @enum {string}
+         */
+        ProviderTechnicalSupportLevel: ProviderTechnicalSupportLevel;
         /**
-         * @description Provider locality for a model worker capability declaration.
+         * @description How an implementation is supplied. Availability is publication metadata, not a live readiness or installation result.
          * @enum {string}
          */
-        WorkerModelLocality: WorkerModelLocality;
+        ProviderImplementationAvailability: ProviderImplementationAvailability;
+        /** @description One stable public documentation resource for a provider. */
+        ProviderDocumentationLink: {
+            kind: components["schemas"]["ProviderDocumentationLinkKind"];
+            /**
+             * Format: uri
+             * @description Public HTTPS documentation URL with a DNS hostname. Machine-local, IP-address, and credential-bearing URLs are invalid.
+             */
+            url: string;
+        };
         /**
-         * @description Concrete worker-provider wrappers supported by the public factory-config contract.
+         * @description Purpose of one stable public provider documentation link.
          * @enum {string}
          */
-        WorkerProvider: WorkerProvider;
+        ProviderDocumentationLinkKind: ProviderDocumentationLinkKind;
+        /** @description Maximum evidenced execution features of the provider integration. These values are independent of support posture and do not imply current-machine readiness. */
+        ProviderExecutionCapabilities: {
+            /** @description Accepts authored prompt input for execution. */
+            promptSubmission: boolean;
+            /** @description Accepts image content as invocation input. */
+            imageInput: boolean;
+            /** @description Can continue an identified provider session. */
+            sessionResume: boolean;
+            /** @description Can constrain authoritative output using a structured schema. */
+            structuredOutput: boolean;
+            /** @description Can execute provider-managed tools during an invocation. */
+            toolExecution: boolean;
+            /** @description Can execute with an explicit working directory. */
+            workingDirectory: boolean;
+            /** @description Can execute against an isolated source-control worktree. */
+            worktree: boolean;
+        };
+        /** @description Maximum evidenced response-event fidelity of the provider integration. Capabilities describe observable output independently of support posture. */
+        ProviderResponseFidelityCapabilities: {
+            /** @description Exposes native streaming observations. */
+            nativeStreaming: boolean;
+            /** @description Emits incremental assistant-message deltas. */
+            messageDeltas: boolean;
+            /** @description Emits assistant-message snapshots. */
+            messageSnapshots: boolean;
+            /** @description Emits reasoning summaries or reasoning deltas. */
+            reasoningSummaries: boolean;
+            /** @description Emits correlated tool lifecycle metadata. */
+            toolLifecycle: boolean;
+            /** @description Emits incremental tool-output deltas. */
+            toolOutputDeltas: boolean;
+            /** @description Emits observed file changes. */
+            fileChanges: boolean;
+            /** @description Emits plan updates. */
+            plans: boolean;
+            /** @description Emits usage accounting. */
+            usage: boolean;
+            /** @description Assigns stable item identifiers across response events. */
+            stableItemIds: boolean;
+            /** @description Supports reconnecting an interrupted provider response stream. */
+            providerReconnect: boolean;
+        };
+        /** @description Static, credential-free facts that tooling may use to explain how a provider can be discovered. Only names and endpoint kinds are published: credential values, environment values, endpoint addresses, machine-local paths, installation/readiness state, and pricing are outside this contract. */
+        ProviderDiscoveryPrerequisites: {
+            /** @description Executable basenames that may supply the provider integration. */
+            executableNames: string[];
+            /** @description Credential-free endpoint transport kinds; addresses and live status are not published. */
+            endpointKinds: components["schemas"]["ProviderDiscoveryEndpointKind"][];
+            /** @description Required configuration-key names only; configuration and environment values are forbidden. */
+            configurationKeys: string[];
+        };
+        /**
+         * @description Static endpoint transport kind that may be checked without credentials.
+         * @enum {string}
+         */
+        ProviderDiscoveryEndpointKind: ProviderDiscoveryEndpointKind;
+        /** @description Coherent metadata for a deprecated provider entry. Presence of this object means the provider is deprecated. replacementProviderId, when present, must name a different canonical provider in the same catalog; it cannot identify the deprecated provider itself. */
+        ProviderDeprecation: {
+            /**
+             * Format: date
+             * @description UTC calendar date on which the catalog began marking the provider deprecated.
+             */
+            deprecatedSince: string;
+            /** @description Localizable explanation of why the provider is deprecated. */
+            reason: components["schemas"]["NameValue"];
+            /** @description Canonical ID of a different, non-deprecated replacement provider in this catalog. */
+            replacementProviderId?: string;
+        };
+        /**
+         * @description Provider locality for a model worker capability declaration.
+         * @enum {string}
+         */
+        WorkerModelLocality: WorkerModelLocality;
+        /** @description Worker execution mechanism. Canonical values are ACP and SCRIPT_WRAP; extensible lowercase identities remain accepted for compatibility with existing factories. */
+        WorkerProvider: string;
         /** @description One provider-agnostic operation exposed by a model worker, such as `TTS`. */
         ModelOperation: {
             name: components["schemas"]["ModelOperationName"];
@@ -4346,6 +4556,8 @@ export interface components {
             id?: string;
             /** @description Customer-authored workstation name used by guards, diagnostics, and authored references. */
             name: string;
+            /** @description Optional localized customer-facing explanation of this workstation. */
+            description?: components["schemas"]["NameValue"];
             /** @description Scheduling behavior for this workstation, such as STANDARD, REPEATER, or CRON execution. */
             behavior?: components["schemas"]["WorkstationKind"];
             /** @description Runtime workstation implementation type, equivalent to the workstation AGENTS.md frontmatter type. */
@@ -4358,8 +4570,6 @@ export interface components {
             worker: string;
             /** @description Optional workstation-specific runner override. When omitted, dispatch falls back to the factory runner, then worker modelProvider compatibility when no explicit runner is configured, then the default codex runner. */
             runner?: components["schemas"]["RunnerID"];
-            /** @description Optional OpenCode agent profile override for this workstation. When set, overrides the worker default for OpenCode dispatches and invokes `opencode run --agent <name>`. Discover agent names with `opencode agent list` (see https://opencode.ai/docs/cli/). */
-            openCodeAgent?: string;
             /** @description Path to a prompt template file loaded for model-oriented workstation execution. */
             promptFile?: string;
             /** @description JSON schema string used to validate or parse structured model output when configured. */
@@ -4418,6 +4628,12 @@ export interface components {
             maxRetries?: number;
             /** @description Go duration limit for one dispatch attempt before it times out. */
             maxExecutionTime?: string;
+            /** @description Fixed maximum number of Work items one accepted worker-emitted FACTORY_REQUEST_BATCH may contain. */
+            maxGeneratedWorkItems?: number;
+            /** @description Optional invocation argument whose positive integer value tightens the fixed generated-Work ceiling. */
+            maxGeneratedWorkItemsArgument?: string;
+            /** @description Offset added to the invocation argument before applying the generated-Work ceiling. */
+            maxGeneratedWorkItemsArgumentOffset?: number;
         };
         /**
          * @description Scheduling kind for a workstation, which determines how the engine schedules and dispatches work to it. Standard workstations are scheduled as soon as their inputs are ready, and can have multiple work items in-flight at the same time.  Repeater workstations are triggered whenever their inputs change, and will reloop the outputs on rejection back to the initial place. Cron workstations create internal time work and dispatch their configured worker when time and input guards are satisfied. Poller workstations bind a poller-capable worker that the service runtime supervises as a long-lived ingress loop.
@@ -4430,10 +4646,12 @@ export interface components {
          * @enum {string}
          */
         WorkstationType: WorkstationType;
-        /** @description Trigger timing for cron workstations. Cron workstations use a schedule expression; interval triggers are not supported. */
+        /** @description Trigger timing for scheduled workstations. Provide exactly one of a five-field cron schedule or a positive duration in every; Factory validation enforces the exclusive choice. */
         WorkstationCron: {
             /** @description Standard five-field cron expression used to produce internal time work while the factory service is running. */
-            schedule: string;
+            schedule?: string;
+            /** @description Positive Go duration interval, such as 30s, 5m, 1h, or 1h30m, used instead of schedule. */
+            every?: string;
             /**
              * @description When true, service startup submits one immediate internal time work item before waiting for the next scheduled cron fire.
              * @default false
@@ -4465,8 +4683,10 @@ export interface components {
             type: components["schemas"]["GuardType"];
             /** @description For `VISIT_COUNT` guards, the workstation whose visits are counted. */
             workstation?: string;
-            /** @description For `VISIT_COUNT` guards, the visit threshold. */
+            /** @description For `VISIT_COUNT` guards, the fixed visit ceiling. */
             maxVisits?: number;
+            /** @description Optional invocation argument whose positive integer value tightens the fixed visit ceiling. */
+            maxVisitsArgument?: string;
             /** @description For `MATCHES_FIELDS` guards, the field-selector configuration used to compare candidate inputs. */
             matchConfig?: components["schemas"]["GuardMatchConfig"];
             /** @description For parent-aware input guards, the parent workType name from another input in the same workstation. */
@@ -4759,6 +4979,68 @@ export interface components {
             /** @description Canonical validation targets for the submitted factory definition. */
             targets: components["schemas"]["FactoryValidationTarget"][];
         };
+        /** @description Shared operator configuration stored in .you-agent-factory/config.json. */
+        GlobalConfig: {
+            /** @description Stable identifier for the local provider-backed runtime boundary. */
+            backendScopeID?: string;
+            defaults?: components["schemas"]["GlobalConfigDefaults"];
+            runtime?: components["schemas"]["GlobalConfigRuntime"];
+            workers?: components["schemas"]["GlobalConfigWorkers"];
+            /** @description Named worker model presets loaded from the shared configuration file. */
+            workerPresets?: components["schemas"]["GlobalConfigWorkerPreset"][];
+        };
+        /** @description Operator defaults that participate independently in file, environment, and flag precedence. */
+        GlobalConfigDefaults: {
+            /** @description Default worker model provider, including supported aliases and symbolic DEFAULT resolution. */
+            workerModelProvider?: string;
+            /** @description Default worker model name. */
+            workerModel?: string;
+        };
+        /** @description Runtime observability settings loaded from operator configuration before command-line overrides. */
+        GlobalConfigRuntime: {
+            /** @description Structured runtime log storage settings. Omitted values use the documented production defaults. */
+            logging?: components["schemas"]["GlobalConfigRuntimeArtifactSettings"];
+            /** @description Runtime metrics storage settings. Omitted values use the documented production defaults. */
+            metrics?: components["schemas"]["GlobalConfigRuntimeArtifactSettings"];
+        };
+        /** @description Rolling-file storage settings for one runtime observability artifact. */
+        GlobalConfigRuntimeArtifactSettings: {
+            /** @description Optional artifact root. Omission uses the runtime-owned directory below the operator home. */
+            directory?: string;
+            /**
+             * @description Maximum artifact file size in megabytes before rotation.
+             * @default 100
+             */
+            maxSizeMB: number;
+            /**
+             * @description Maximum number of rotated artifact files to retain.
+             * @default 20
+             */
+            maxBackups: number;
+            /**
+             * @description Maximum age in days for rotated artifact files.
+             * @default 30
+             */
+            maxAgeDays: number;
+            /**
+             * @description Whether rotated artifact files are gzip-compressed.
+             * @default false
+             */
+            compress: boolean;
+        };
+        /** @description Named worker model selection available to Factory Session runtime opening. */
+        GlobalConfigWorkerPreset: {
+            /** @description Non-empty preset identifier after surrounding whitespace is trimmed. */
+            id: string;
+            modelProvider: components["schemas"]["GlobalConfigWorkerPresetModelProvider"];
+            /** @description Optional model name, trimmed when present. */
+            model?: string;
+            reasoningEffort?: components["schemas"]["GlobalConfigWorkerPresetReasoningEffort"];
+        };
+        /** @description Canonical provider identity or built-in compatibility alias; surrounding whitespace is trimmed, and symbolic DEFAULT is not accepted for presets. */
+        GlobalConfigWorkerPresetModelProvider: string;
+        /** @description Optional reasoning effort; surrounding whitespace and letter case are normalized, and an empty value is treated as unspecified. */
+        GlobalConfigWorkerPresetReasoningEffort: string;
         WorkRequest: {
             /** @description Stable client-provided request identifier used for idempotent batch submission. */
             requestId: string;
@@ -5114,6 +5396,8 @@ export interface components {
          * @enum {string}
          */
         HostedWorkerProvider: HostedWorkerProvider;
+        /** @description Optional provider-neutral reasoning effort. Surrounding whitespace and letter case are normalized. Omit the field to preserve the selected provider and model default. Factory definitions may use an exact invocation-parameter placeholder such as `${executorReasoningEffort}`. */
+        ReasoningEffort: string;
         /** @description Hosted-worker authentication contract. V1 hosted workers accept only secret references rather than inline credentials or OAuth-style fields. */
         HostedWorkerAuth: {
             /** @description Referenced secret name that resolves the hosted provider API key at runtime. */
@@ -5177,8 +5461,10 @@ export interface components {
             type: components["schemas"]["WorkstationGuardType"];
             /** @description For `VISIT_COUNT` guards, the workstation whose visits are counted. */
             workstation?: string;
-            /** @description For `VISIT_COUNT` guards, the visit threshold. */
+            /** @description For `VISIT_COUNT` guards, the fixed visit ceiling. */
             maxVisits?: number;
+            /** @description Optional invocation argument whose positive integer value tightens the fixed visit ceiling. */
+            maxVisitsArgument?: string;
             /** @description For `MATCHES_FIELDS` guards, the field-selector configuration used to compare candidate inputs. */
             matchConfig?: components["schemas"]["GuardMatchConfig"];
             /** @description For parent-aware input guards, the parent workType name from another input in the same workstation. */
@@ -5188,6 +5474,33 @@ export interface components {
             /** @description For dynamic fanout input guards, the workstation that spawns the children for count tracking. */
             spawnedBy?: string;
         };
+        GlobalConfigACPIntegration: {
+            /** @description Stable settings-entry identity. This is distinct from the provider name selected by a Worker. */
+            id: string;
+            /** @description Canonical Providers catalog identity, such as cursor-acp. */
+            name: string;
+            /**
+             * @description ACP transport. P0 supports stdio only.
+             * @enum {string}
+             */
+            transport: GlobalConfigACPIntegrationTransport;
+            /** @description Operator-authored ACP launch command preserved as one settings value. It contains no permission or timeout policy. */
+            command: string;
+        };
+        GlobalConfigACPAgentProfile: {
+            /** @description Unversioned namespaced Factory target reference, such as factory:@you/factory-builder. Factory Definitions owns enumeration and canonical reference resolution. */
+            defaultTarget: string;
+            /** @description Ordered allowlist of unversioned namespaced Factory target references. Order is authored and preserved. */
+            allowedTargets: string[];
+        };
+        GlobalConfigACPSettings: {
+            /** @description Operator-selected ACP provider integrations. Availability is derived by the Providers catalog and is never persisted here. */
+            integrations?: components["schemas"]["GlobalConfigACPIntegration"][];
+            agentProfile?: components["schemas"]["GlobalConfigACPAgentProfile"];
+        };
+        GlobalConfigWorkers: {
+            acp?: components["schemas"]["GlobalConfigACPSettings"];
+        };
     };
     responses: {
         /** @description Request payload or parameter was invalid. */
@@ -5625,6 +5938,8 @@ export interface operations {
                     "X-Factory-Session-Factory-Session-Id"?: string;
                     /** @description Opaque invalidation token for the current live Factory Session event history. Compare this handshake header with session-sync or preflight `streamGenerationID` values before reusing reconnect cursors or stream-derived projections. */
                     "X-Factory-Session-Stream-Generation-Id"?: string;
+                    /** @description Count of already-committed canonical FactoryEvent records written as the retained-history prefix before any live event, captured at subscribe time. A bounded reader can read exactly this many leading data frames instead of inferring completion from stream quiescence. */
+                    "X-Factory-Session-Retained-Event-Count"?: number;
                     [name: string]: unknown;
                 };
                 content: {
@@ -6672,6 +6987,27 @@ export interface operations {
             500: components["responses"]["InternalError"];
         };
     };
+    listPackagedFactories: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Published packaged factory catalog. */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["PackagedFactoryCatalogResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+        };
+    };
 }
 export declare const InvocationInputSourceKind: {
     readonly InvocationInputSourceKindText: "text";
@@ -6798,6 +7134,7 @@ export declare const ErrorResponseCode: {
     readonly FACTORY_NOT_IDLE: "FACTORY_NOT_IDLE";
     readonly STALE_FACTORY_VERSION: "STALE_FACTORY_VERSION";
     readonly MOVE_WORK_REQUEST_ALREADY_APPLIED: "MOVE_WORK_REQUEST_ALREADY_APPLIED";
+    readonly METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED";
     readonly EXECUTION_REQUEST_ID_CONFLICT: "EXECUTION_REQUEST_ID_CONFLICT";
     readonly FACTORY_SESSION_CONTROL_REQUEST_ALREADY_APPLIED: "FACTORY_SESSION_CONTROL_REQUEST_ALREADY_APPLIED";
     readonly INVALID_RESPONSE_EVENT_CURSOR: "INVALID_RESPONSE_EVENT_CURSOR";
@@ -7028,6 +7365,10 @@ export declare const ProviderSessionTranscriptEntryType: {
     readonly system_event: "system_event";
 };
 export type ProviderSessionTranscriptEntryType = (typeof ProviderSessionTranscriptEntryType)[keyof typeof ProviderSessionTranscriptEntryType];
+export declare const NameValueType: {
+    readonly LOCALIZABLE_ASSET: "LOCALIZABLE_ASSET";
+};
+export type NameValueType = (typeof NameValueType)[keyof typeof NameValueType];
 export declare const FactoryWorldWorkItemRefPayloadStatus: {
     readonly RESOLVED: "RESOLVED";
     readonly UNAVAILABLE: "UNAVAILABLE";
@@ -7079,6 +7420,7 @@ export declare const FactoryEventType: {
     readonly FactoryEventTypeWorkRequest: "WORK_REQUEST";
     readonly FactoryEventTypeRelationshipChangeRequest: "RELATIONSHIP_CHANGE_REQUEST";
     readonly FactoryEventTypeDispatchRequest: "DISPATCH_REQUEST";
+    readonly FactoryEventTypeDispatchWorkerSessionAssociation: "DISPATCH_WORKER_SESSION_ASSOCIATION";
     readonly FactoryEventTypeModelRequest: "MODEL_REQUEST";
     readonly FactoryEventTypeModelResponse: "MODEL_RESPONSE";
     readonly FactoryEventTypeInferenceRequest: "INFERENCE_REQUEST";
@@ -7348,23 +7690,48 @@ export type WorkerType = (typeof WorkerType)[keyof typeof WorkerType];
 export declare const WorkerModelProvider: {
     readonly CLAUDE: "CLAUDE";
     readonly CODEX: "CODEX";
-    readonly CURSOR: "CURSOR";
-    readonly GEMINI: "GEMINI";
-    readonly KIRO: "KIRO";
-    readonly OPENCODE: "OPENCODE";
-    readonly PI: "PI";
-    readonly AGY: "AGY";
+    readonly ANTIGRAVITY: "ANTIGRAVITY";
 };
 export type WorkerModelProvider = (typeof WorkerModelProvider)[keyof typeof WorkerModelProvider];
+export declare const ProviderCatalogFormatVersion: {
+    readonly Value1_0_0: "1.0.0";
+};
+export type ProviderCatalogFormatVersion = (typeof ProviderCatalogFormatVersion)[keyof typeof ProviderCatalogFormatVersion];
+export declare const ProviderCatalogProviderSchema: {
+    readonly https_schemas_you_dev_model_providers_provider_manifest_1_0_0_schema_json: "https://schemas.you.dev/model-providers/provider-manifest/1.0.0.schema.json";
+};
+export type ProviderCatalogProviderSchema = (typeof ProviderCatalogProviderSchema)[keyof typeof ProviderCatalogProviderSchema];
+export declare const ProviderTechnicalSupportLevel: {
+    readonly production: "production";
+    readonly experimental: "experimental";
+    readonly not_supported: "not-supported";
+};
+export type ProviderTechnicalSupportLevel = (typeof ProviderTechnicalSupportLevel)[keyof typeof ProviderTechnicalSupportLevel];
+export declare const ProviderImplementationAvailability: {
+    readonly bundled: "bundled";
+    readonly externally_supplied: "externally-supplied";
+    readonly catalog_only: "catalog-only";
+};
+export type ProviderImplementationAvailability = (typeof ProviderImplementationAvailability)[keyof typeof ProviderImplementationAvailability];
+export declare const ProviderDocumentationLinkKind: {
+    readonly homepage: "homepage";
+    readonly setup: "setup";
+    readonly reference: "reference";
+    readonly support: "support";
+};
+export type ProviderDocumentationLinkKind = (typeof ProviderDocumentationLinkKind)[keyof typeof ProviderDocumentationLinkKind];
+export declare const ProviderDiscoveryEndpointKind: {
+    readonly local_http: "local-http";
+    readonly remote_http: "remote-http";
+    readonly stdio: "stdio";
+    readonly unix_socket: "unix-socket";
+};
+export type ProviderDiscoveryEndpointKind = (typeof ProviderDiscoveryEndpointKind)[keyof typeof ProviderDiscoveryEndpointKind];
 export declare const WorkerModelLocality: {
     readonly LOCAL: "LOCAL";
     readonly CLOUD: "CLOUD";
 };
 export type WorkerModelLocality = (typeof WorkerModelLocality)[keyof typeof WorkerModelLocality];
-export declare const WorkerProvider: {
-    readonly SCRIPT_WRAP: "SCRIPT_WRAP";
-};
-export type WorkerProvider = (typeof WorkerProvider)[keyof typeof WorkerProvider];
 export declare const ModelOperationContentType: {
     readonly TEXT: "TEXT";
     readonly IMAGE: "IMAGE";
@@ -7375,11 +7742,8 @@ export declare const ModelOperationContentType: {
 export type ModelOperationContentType = (typeof ModelOperationContentType)[keyof typeof ModelOperationContentType];
 export declare const RunnerID: {
     readonly codex: "codex";
-    readonly gemini: "gemini";
-    readonly kiro: "kiro";
-    readonly cursor_cli: "cursor-cli";
-    readonly opencode: "opencode";
-    readonly pi: "pi";
+    readonly claude: "claude";
+    readonly antigravity: "antigravity";
 };
 export type RunnerID = (typeof RunnerID)[keyof typeof RunnerID];
 export declare const RunnerSelectionSource: {
@@ -7581,6 +7945,10 @@ export declare const WorkstationGuardType: {
     readonly MATCHES_FIELDS: "MATCHES_FIELDS";
 };
 export type WorkstationGuardType = (typeof WorkstationGuardType)[keyof typeof WorkstationGuardType];
+export declare const GlobalConfigACPIntegrationTransport: {
+    readonly stdio: "stdio";
+};
+export type GlobalConfigACPIntegrationTransport = (typeof GlobalConfigACPIntegrationTransport)[keyof typeof GlobalConfigACPIntegrationTransport];
 export declare const ComponentsParametersSortBy: {
     readonly state_type: "state.type";
 };