@cadenya/cadenya 1.0.1 → 1.1.0

package/dist/types.d.ts

@@ -5,13 +5,42 @@
  *  is fixed and intentionally not overridable here; use the OpenAI-compatible
  *  provider to target a custom endpoint.
  */
-export type AIProviderConfig = AIProviderConfig_Openrouter | AIProviderConfig_Openai | AIProviderConfig_OpenaiCompatible;
+export type AIProviderConfig = AIProviderConfig_Openrouter | AIProviderConfig_Openai | AIProviderConfig_OpenaiCompatible | AIProviderConfig_Vertex | AIProviderConfig_Bedrock;
 /**
  * AIProviderCredential is the secret material used to authenticate with a
  *  provider. The set case must correspond to AIProviderKeySpec.provider. The
- *  server encrypts the serialized message at rest and never returns it on reads.
+ *  server classifies and encrypts sensitive fields at rest and never returns
+ *  secret values on reads.
  */
-export type AIProviderCredential = AIProviderCredential_ApiKey | AIProviderCredential_Headers;
+export type AIProviderCredential = AIProviderCredential_ApiKey | AIProviderCredential_Headers | AIProviderCredential_GoogleServiceAccount | AIProviderCredential_AwsAccessKey;
+/**
+ * AIProviderCredentialFieldStatus is the safe read representation of one
+ *  credential field. Value is populated only when sensitive is false.
+ */
+export interface AIProviderCredentialFieldStatus {
+    name?: string;
+    sensitive?: boolean;
+    configured?: boolean;
+    value?: string;
+}
+/**
+ * AIProviderCredentialPatch changes selected fields of the current credential.
+ *  Omitted values are retained and clear_fields explicitly removes optional
+ *  fields. Changing type replaces the credential and requires all mandatory
+ *  fields for the new type.
+ */
+export interface AIProviderCredentialPatch {
+    credentials?: AIProviderCredential;
+    clearFields?: Array<string>;
+}
+/**
+ * AIProviderCredentialStatus describes the stored authentication method and
+ *  its fields without returning secret material.
+ */
+export interface AIProviderCredentialStatus {
+    type?: string;
+    fields?: Array<AIProviderCredentialFieldStatus>;
+}
 /**
  * AIProviderKey is a credential for an AI provider, scoped to a workspace.
  *  Most keys are customer-provided (BYOK); Cadenya also provisions promotional
@@ -28,6 +57,10 @@ export interface AIProviderKey {
      */
     info?: AIProviderKeyInfo;
 }
+/**
+ * How models on this key are maintained; see ModelManagement.
+ */
+export type AiProviderKeyInfoModelManagement = 'MODEL_MANAGEMENT_UNSPECIFIED' | 'MODEL_MANAGEMENT_CADENYA' | 'MODEL_MANAGEMENT_SYNCED' | 'MODEL_MANAGEMENT_CUSTOMIZABLE' | 'MODEL_MANAGEMENT_MANUAL';
 /**
  * AIProviderKeyInfo carries server-derived, read-only details about a key, for
  *  AI provider management UIs.
@@ -46,11 +79,20 @@ export interface AIProviderKeyInfo {
      *  These are not added or maintained by account administrators.
      */
     isPromotional: boolean;
+    /**
+     * Safe-to-display credential state. Secret values are never populated;
+     *  configured reports whether a value is present without revealing it.
+     */
+    credentialStatus?: AIProviderCredentialStatus;
+    /**
+     * How models on this key are maintained; see ModelManagement.
+     */
+    modelManagement: AiProviderKeyInfoModelManagement;
 }
 /**
  * The AI provider this key authenticates against.
  */
-export type AiProviderKeySpecProvider = 'AI_PROVIDER_UNSPECIFIED' | 'AI_PROVIDER_OPENROUTER' | 'AI_PROVIDER_OPENAI' | 'AI_PROVIDER_ANTHROPIC' | 'AI_PROVIDER_GEMINI' | 'AI_PROVIDER_OPENAI_COMPATIBLE';
+export type AiProviderKeySpecProvider = 'AI_PROVIDER_UNSPECIFIED' | 'AI_PROVIDER_OPENROUTER' | 'AI_PROVIDER_OPENAI' | 'AI_PROVIDER_ANTHROPIC' | 'AI_PROVIDER_GEMINI' | 'AI_PROVIDER_OPENAI_COMPATIBLE' | 'AI_PROVIDER_VERTEX' | 'AI_PROVIDER_BEDROCK';
 export interface AIProviderKeySpec {
     /**
      * The AI provider this key authenticates against.
@@ -63,8 +105,9 @@ export interface AIProviderKeySpec {
     credentials?: AIProviderCredential;
     /**
      * Non-secret, provider-specific settings (OpenAI org/project, OpenRouter
-     *  region, OpenAI-compatible base URL). The set case must correspond to
-     *  `provider`. Returned on reads. Optional: omit to accept provider defaults.
+     *  region, OpenAI-compatible base URL, Vertex project/location, or Bedrock
+     *  Region). The set case must correspond to `provider`. Returned on reads.
+     *  Optional for providers that have usable defaults.
      */
     config?: AIProviderConfig;
 }
@@ -406,7 +449,7 @@ export interface AgentScheduleSpec_Schedule {
 }
 /**
  * Controls how variations are automatically selected when creating objectives
- *  Defaults to RANDOM when unspecified
+ *  Defaults to WEIGHTED when unspecified
  */
 export type AgentSpecVariationSelectionMode = 'VARIATION_SELECTION_MODE_UNSPECIFIED' | 'VARIATION_SELECTION_MODE_RANDOM' | 'VARIATION_SELECTION_MODE_WEIGHTED';
 /**
@@ -423,9 +466,9 @@ export interface AgentSpec {
     webhookEventsUrl?: string;
     /**
      * Controls how variations are automatically selected when creating objectives
-     *  Defaults to RANDOM when unspecified
+     *  Defaults to WEIGHTED when unspecified
      */
-    variationSelectionMode: AgentSpecVariationSelectionMode;
+    variationSelectionMode?: AgentSpecVariationSelectionMode;
     /**
      * SystemPromptDataSchema enforces the shape of system_prompt_data when objectives are created. This is valuable when using liquid formatting in agent
      *  variation system prompt templates. The schema is also used when the agent is attached as a sub-agent, as it becomes the tool's input parameter schema.
@@ -595,10 +638,8 @@ export interface AgentVariationSpec_Constraints {
      *  When not set, objectives are still swept at the system-wide 24 hour
      *  maximum — every objective eventually reaches a terminal state.
      *
-     *  Note: no gnostic integer hint here on purpose. The Envoy gRPC-JSON
-     *  transcoder only accepts the canonical protobuf JSON form for
-     *  Durations — a "<seconds>s" string — so the SDKs must type this as a
-     *  string (like AgentScheduleSpec.every), not an integer.
+     *  SDKs represent this as a duration string, like AgentScheduleSpec.every,
+     *  rather than an integer.
      */
     inactivityTimeout?: string;
 }
@@ -614,7 +655,7 @@ export type AgentVariationSpecModelConfigReasoningEffort = 'REASONING_EFFORT_UNS
  */
 export interface AgentVariationSpec_ModelConfig {
     /**
-     * The model identifier in family/model format (e.g., "claude/opus-4.6", "claude/sonnet-4.5")
+     * The model identifier for the agent variation to use. Should be either the reference key (ai-provider.model-name) or the canonical model ID (e.g.: "model_ABC123")
      */
     modelId: string;
     /**
@@ -772,10 +813,16 @@ export interface BareMetadata {
     /**
      * Human-readable name of the referenced resource, populated by the server
      *  on reads for convenience. Absent on references to resources that do not
-     *  have a name (e.g., objective tasks).
+     *  have a name.
      */
     name?: string;
 }
+/**
+ * BedrockConfig selects the AWS source Region used for Bedrock Runtime calls.
+ */
+export interface BedrockConfig {
+    region?: string;
+}
 /**
  * CallableTool is a union that represents a tool that can be called by an agent. In Cadenya, a tool that is used within an agent objective
  *  might be a user-defined tool (IE: MCP, HTTP), another Agent (useful to separate context), or a Cadenya Tool (one Cadenya provides).
@@ -1110,6 +1157,25 @@ export interface CreateMemoryLayerRequest {
     metadata: CreateResourceMetadata;
     spec: MemoryLayerSpec;
 }
+/**
+ * Create model request. The model is created on the given AI provider key with
+ *  PROVENANCE_MANUALLY_ENTERED and STATE_ENABLED. The key must be customer
+ *  provided and its provider must accept manual definitions (see
+ *  AIProviderKeyInfo.model_management).
+ */
+export interface CreateModelRequest {
+    /**
+     * Workspace ID.
+     */
+    workspaceId?: string;
+    /**
+     * The AI provider key the model routes through. Accepts the canonical
+     *  `aipk_…` form or the `external_id:<value>` form.
+     */
+    aiProviderKeyId?: string;
+    metadata: CreateResourceMetadata;
+    spec: ModelSpec;
+}
 /**
  * Request to submit feedback for an objective
  */
@@ -1190,9 +1256,12 @@ export interface CreateObjectiveRequest {
     subject?: SubjectAssertion;
     /**
      * Parameters forced onto this objective's tool calls. A pinned parameter
-     *  is an overlay on a tool's JSON schema: the parameter is removed from
-     *  what the LLM sees, and its value is always overwritten server-side with
-     *  the pinned value — the model cannot choose a different value for it.
+     *  is removed from the tool schema the LLM sees, and its value is always
+     *  overwritten server-side with the pinned value — the model cannot choose
+     *  a different value for it. By default a pinned key applies to every tool
+     *  with a top-level parameter of the same name; a tool set's overlays
+     *  (ToolSetSpec.overlays) can bind pinned keys to nested paths, differently
+     *  named parameters, or a subset of tools.
      */
     pinnedParameters?: Record<string, string>;
 }
@@ -1340,6 +1409,22 @@ export interface CreateWorkspaceSecretRequest {
 export interface CredentialAPIKey {
     apiKey?: string;
 }
+/**
+ * CredentialAWSAccessKey carries AWS SigV4 credentials. Optional presence is
+ *  used by credential patches so omitted values remain unchanged.
+ */
+export interface CredentialAWSAccessKey {
+    accessKeyId?: string;
+    secretAccessKey?: string;
+    sessionToken?: string;
+}
+/**
+ * CredentialGoogleServiceAccount carries an in-memory Google service-account
+ *  credential document.
+ */
+export interface CredentialGoogleServiceAccount {
+    json?: string;
+}
 /**
  * CredentialHeaders carries arbitrary HTTP headers sent with every request to
  *  the provider (e.g. {"Authorization": "Bearer ...", "X-Api-Key": "..."}).
@@ -1423,7 +1508,7 @@ export interface EnableModelRequest {
 }
 export interface GetObjectiveDiagnosticsResponse {
     /**
-     * Diagnostics from the objective's most recent iteration.
+     * Context usage from the objective's most recent iteration.
      */
     diagnostics: ObjectiveDiagnostics;
 }
@@ -1519,10 +1604,6 @@ export interface ListObjectiveFeedbackResponse {
     items: Array<ObjectiveFeedback>;
     pagination?: Page;
 }
-export interface ListObjectiveTasksResponse {
-    items: Array<ObjectiveTask>;
-    pagination?: Page;
-}
 export interface ListObjectiveToolCallsResponse {
     items: Array<ObjectiveToolCall>;
     pagination?: Page;
@@ -1834,6 +1915,12 @@ export interface MemoryReference {
  *  :enable and :disable actions to transition.
  */
 export type ModelState = 'STATE_UNSPECIFIED' | 'STATE_ENABLED' | 'STATE_DISABLED';
+/**
+ * Where this definition came from. Output only; set at creation. Synced
+ *  models reject edits to metadata.name and spec, manually entered models
+ *  accept them.
+ */
+export type ModelProvenance = 'PROVENANCE_UNSPECIFIED' | 'PROVENANCE_SYNCED_FROM_PROVIDER' | 'PROVENANCE_MANUALLY_ENTERED';
 export interface Model {
     /**
      * Resource metadata
@@ -1853,6 +1940,39 @@ export interface Model {
      *  :enable and :disable actions to transition.
      */
     state: ModelState;
+    /**
+     * Where this definition came from. Output only; set at creation. Synced
+     *  models reject edits to metadata.name and spec, manually entered models
+     *  accept them.
+     */
+    provenance: ModelProvenance;
+    /**
+     * Customer price overrides. Output only here; set through UpdateModel with
+     *  pricing_override.* mask paths. When an override is present, spec's price
+     *  fields already reflect it (they are the effective prices).
+     */
+    pricingOverride?: ModelPricingOverride;
+    /**
+     * The rates before any customer override: the catalog rate for a synced
+     *  model, the entered rate for a manually entered one. Output only. When a
+     *  side matches the spec price, an override may still be present; inspect
+     *  pricing_override field presence to determine whether an override is set.
+     */
+    basePricing: ModelBasePricing;
+}
+/**
+ * ModelBasePricing is a model's default rates in cents per million tokens,
+ *  unaffected by pricing overrides. Zero means the rate is not known.
+ */
+export interface ModelBasePricing {
+    /**
+     * Default input token rate, in cents per million tokens.
+     */
+    inputPricePerMillionTokens: string;
+    /**
+     * Default output token rate, in cents per million tokens.
+     */
+    outputPricePerMillionTokens: string;
 }
 /**
  * ModelInfo carries server-derived, read-only details about a model.
@@ -1875,6 +1995,21 @@ export interface ModelInfo {
      */
     lastUsedAt?: string;
 }
+/**
+ * ModelPricingOverride replaces the catalog prices for a model. Each field is
+ *  independent: an absent field keeps the catalog price, a present field (zero
+ *  included) replaces it. Prices are cents per million tokens.
+ */
+export interface ModelPricingOverride {
+    /**
+     * Override for input token price, in cents per million tokens.
+     */
+    inputPricePerMillionTokens?: string;
+    /**
+     * Override for output token price, in cents per million tokens.
+     */
+    outputPricePerMillionTokens?: string;
+}
 export interface ModelSpec {
     /**
      * The model provider (e.g., "anthropic", "openai", "google")
@@ -1893,11 +2028,16 @@ export interface ModelSpec {
      */
     maxOutputTokens: number;
     /**
-     * Cost per million input tokens in cents (e.g., 300 = $3.00)
+     * Cost per million input tokens in cents (e.g., 300 = $3.00). On reads this
+     *  is the effective price: the catalog price unless
+     *  Model.pricing_override replaces it. Writes only apply to manually
+     *  entered models; use UpdateModel's pricing_override paths to override a
+     *  synced model's price.
      */
     inputPricePerMillionTokens: string;
     /**
-     * Cost per million output tokens in cents (e.g., 1500 = $15.00)
+     * Cost per million output tokens in cents (e.g., 1500 = $15.00). Effective
+     *  price on reads, see input_price_per_million_tokens.
      */
     outputPricePerMillionTokens: string;
     /**
@@ -1906,6 +2046,15 @@ export interface ModelSpec {
      *  (and its mode) lives here too, as the "reasoning" capability.
      */
     capabilities: Array<ModelSpec_Capability>;
+    /**
+     * The identifier the provider expects in inference requests, exactly as the
+     *  provider spells it: an OpenAI model name, a Vertex publisher model
+     *  resource, a Bedrock inference-profile ID or ARN, or an OpenAI-compatible
+     *  endpoint's model ID. Distinct from metadata.external_id, which is
+     *  Cadenya's slug. Verified with a minimal provider completion on creation
+     *  and whenever the identifier changes.
+     */
+    providerModelId: string;
 }
 /**
  * Capability describes one inference knob this model supports, with any
@@ -1915,7 +2064,7 @@ export interface ModelSpec {
 export type ModelSpec_Capability = ModelSpec_Capability_Temperature | ModelSpec_Capability_TopP | ModelSpec_Capability_TopK | ModelSpec_Capability_StopSequences | ModelSpec_Capability_MaxOutputTokens | ModelSpec_Capability_Reasoning | ModelSpec_Capability_Caching;
 export type NoticeLevel = 'LEVEL_UNSPECIFIED' | 'LEVEL_INFO' | 'LEVEL_WARN';
 /**
- * Notice is a non-terminal diagnostic emitted by the runtime when something
+ * Notice is a non-terminal event emitted by the runtime when something
  *  noteworthy but non-fatal happens during an objective — for example a
  *  just-in-time tool set failing to load, or a previously loaded tool being
  *  dropped because it was archived. Notices carry no structured payload; they
@@ -2080,10 +2229,10 @@ export interface ObjectiveContextWindowInfo {
     createdBy?: Profile;
 }
 /**
- * ObjectiveDiagnostics is the context-usage breakdown measured for a single
- *  iteration at request-assembly time. It reports how much of the context
- *  window each component occupies so tool parameters, memory cascades, and
- *  prompts can be tuned against real token usage.
+ * Context-usage breakdown measured for a single iteration at request-assembly
+ *  time. It reports how much of the context window each component occupies so
+ *  tool parameters, memory cascades, and prompts can be tuned against real
+ *  token usage.
  */
 export interface ObjectiveDiagnostics {
     /**
@@ -2257,32 +2406,6 @@ export interface ObjectiveInfo {
      */
     widget?: BareMetadata;
 }
-/**
- * ObjectiveTask represents a task within an objective, typically created and managed by an AI agent
- *  to track progress toward completing the objective.
- */
-export interface ObjectiveTask {
-    metadata: BareMetadata;
-    data: ObjectiveTaskData;
-}
-export interface ObjectiveTaskData {
-    /**
-     * The sequential number of this task within the objective (auto-assigned, 1-based)
-     */
-    number: number;
-    /**
-     * Description of the task to be completed
-     */
-    task: string;
-    /**
-     * Whether the task has been completed
-     */
-    completed: boolean;
-    /**
-     * Timestamp when the task was marked as completed
-     */
-    completedAt?: string;
-}
 /**
  * ObjectiveTimedOut is the terminal event written when an objective is
  *  finalized by the inactivity sweep because it saw no activity (no user
@@ -2363,6 +2486,12 @@ export interface ObjectiveToolCallInfo {
  *  short-lived signed URLs rather than inline bytes.
  */
 export interface ObjectiveToolCallResult {
+    /**
+     * The result content as recorded — which is what the model was shown.
+     *  When a tool set overlay transformed the result (ToolOverlay
+     *  result_actions), this is the transformed content; the adapter's raw
+     *  response is kept in the tool call's debug log, not here.
+     */
     content: Array<ObjectiveToolCallResult_ContentBlock>;
 }
 export interface ObjectiveToolCallResult_AudioBlock {
@@ -2408,6 +2537,11 @@ export interface ObjectiveToolCallResult_ImageBlock {
 }
 export interface ObjectiveToolCallResult_TextBlock {
     text: string;
+    /**
+     * Size of the stored text in bytes. Filled by the server at record time;
+     *  zero on results recorded before this field existed.
+     */
+    sizeBytes?: string;
 }
 /**
  * Current status of the tool call
@@ -2535,6 +2669,78 @@ export interface OperationMetadata {
 export interface Page {
     nextCursor: string;
 }
+/**
+ * Default: ON_MISSING_FAIL.
+ */
+export type ParameterActionPinOnMissing = 'ON_MISSING_UNSPECIFIED' | 'ON_MISSING_FAIL' | 'ON_MISSING_SKIP';
+/**
+ * Bind the parameter to one of the objective's pinned parameters. It is
+ *  deleted from the schema (including any `required` entry), and on every
+ *  call the pinned value is written into the arguments, overwriting
+ *  anything the model supplied.
+ *  This is the authoritative-value action: the model never sees the
+ *  parameter and cannot influence it.
+ *
+ *  `pin` differs from `set` with `{{ pinned_parameters.key }}` only in
+ *  how a missing key is handled (see `on_missing`) and in intent —
+ *  reading the tool set config, `pin` says "this comes from the caller".
+ */
+export interface ParameterAction_Pin {
+    path: string;
+    /**
+     * Key into the objective's pinned_parameters map. Need not equal the
+     *  last segment of `path` — this is how a pinned `orgId` reaches a
+     *  tool whose parameter is named `organizationId`.
+     */
+    pinnedParameter: string;
+    /**
+     * Default: ON_MISSING_FAIL.
+     */
+    onMissing: ParameterActionPinOnMissing;
+}
+/**
+ * Remove the parameter entirely. It is deleted from the schema
+ *  (including any `required` entry) and stripped from the arguments if
+ *  the model supplies it anyway. The tool receives no value for it — the
+ *  upstream default, if any, applies. Use this to save context on
+ *  parameters the model has no business setting (pagination cursors,
+ *  expansion flags, debug toggles).
+ */
+export interface ParameterAction_Remove {
+    path: string;
+}
+/**
+ * Force the parameter to a value. It is deleted from the schema
+ *  (including any `required` entry), and on every call the rendered
+ *  value is written into the arguments, overwriting anything the model
+ *  supplied.
+ *
+ *  `value_template` is a Liquid template rendered against the objective:
+ *
+ *    {{ pinned_parameters.<key> }}  the objective's pinned parameters
+ *    {{ objective.id }}             the objective's id
+ *    {{ objective.external_id }}    the objective's external id
+ *    {{ objective.labels.<key> }}   the objective's labels
+ *
+ *  Templates render with strict variables: referencing a pinned
+ *  parameter or label that does not exist fails the call rather than
+ *  rendering an empty value.
+ *
+ *  Tool set secrets are intentionally not exposed here: overlay-set
+ *  values are recorded as tool call arguments in events and tool call
+ *  history, and would leak. Use adapter headers for credentials.
+ *
+ *  The rendered string is coerced to the parameter's declared schema
+ *  type: for a non-string parameter (integer, number, boolean, object,
+ *  array) the output is parsed as JSON. A value that fails to parse
+ *  errors the tool call. Prefer `pin` when the value is simply a pinned
+ *  parameter — it fails loudly when the key is absent instead of
+ *  rendering an empty string.
+ */
+export interface ParameterAction_Set {
+    path: string;
+    valueTemplate: string;
+}
 /**
  * Pause agent schedule request.
  */
@@ -2689,6 +2895,65 @@ export interface RestoreToolRequest {
      */
     id?: string;
 }
+/**
+ * Default: ON_ERROR_RAW_CONTENT.
+ */
+export type ResultActionTransformOnError = 'ON_ERROR_UNSPECIFIED' | 'ON_ERROR_RAW_CONTENT' | 'ON_ERROR_FAIL';
+/**
+ * Replace the result's text content with a rendered Liquid template.
+ *  Used to compact verbose responses to the fields the model actually
+ *  needs, or to rewrite a JSON response into a smaller JSON document.
+ *
+ *  `content_template` is rendered against the call:
+ *
+ *    {{ result.text }}        the result's text content (text blocks
+ *                             joined with newlines)
+ *    {{ result.json }}        result.text parsed as JSON — objects and
+ *                             arrays are navigable (`result.json.items`,
+ *                             `| map: "id"`); absent when the text is not
+ *                             valid JSON
+ *    {{ result.blocks }}      every content block: [{type, text?,
+ *                             mime_type?, size_bytes?}]
+ *    {{ parameters }}         the arguments the tool was called with,
+ *                             after parameter actions were applied
+ *    {{ tool.name }}          the tool's metadata.name
+ *    {{ tool.llm_tool_name }} the name the model called it by
+ *    {{ pinned_parameters }}  the objective's pinned parameters
+ *    {{ objective.id }} / {{ objective.external_id }} /
+ *    {{ objective.labels.<key> }}
+ *
+ *  Templates render with strict variables: referencing `result.json` on
+ *  a non-JSON result, or any other undefined variable, is a render error
+ *  and `on_error` decides the outcome. The `json` filter pretty-prints a
+ *  value as JSON; `sanitized_json` emits it compact and escaped for
+ *  embedding.
+ *
+ *  Transforms are text-only. `result.text` and `result.json` are built
+ *  from the result's text blocks; media blocks (images, audio) are opaque
+ *  to the template and pass through unchanged. The rendered text replaces
+ *  the text blocks as a single text block. A result with no text blocks
+ *  at all (an image-only or audio-only result) is out of scope: the
+ *  transform is skipped, the result is recorded as returned, and the
+ *  skip is noted in the tool call's debug log — this is not an `on_error`
+ *  case, nothing was attempted. The one exception is `expect_json`, where
+ *  a result with no text is a violated precondition and `on_error`
+ *  applies.
+ */
+export interface ResultAction_Transform {
+    contentTemplate: string;
+    /**
+     * Default: ON_ERROR_RAW_CONTENT.
+     */
+    onError: ResultActionTransformOnError;
+    /**
+     * Require the tool result to have text content that parses as JSON
+     *  before rendering. A non-JSON (or text-less) result is then an error
+     *  subject to `on_error` even if the template never reads
+     *  `result.json`. Off by default: `result.json` is simply absent for
+     *  non-JSON results, and text-less results skip the transform.
+     */
+    expectJson: boolean;
+}
 /**
  * Resume agent schedule request.
  */
@@ -2785,6 +3050,21 @@ export interface SearchToolsOrToolSetsResponse {
     toolSets: Array<ToolSet>;
     agents: Array<Agent>;
 }
+/**
+ * A single selector condition.
+ */
+export type Selector_Condition = Selector_Condition_Attribute | Selector_Condition_HasParameter | Selector_Condition_Tools;
+/**
+ * An explicit list of tools, matched on spec.llm_tool_name — the name
+ *  the model calls the tool by. It identifies a tool across versions:
+ *  just-in-time MCP sets keep one tool per signature and every version
+ *  shares the LLM name, so the condition keeps matching as the source
+ *  evolves. Any name in the list matches (OR). Names of tools not (or
+ *  not yet) present in the set are allowed and match nothing.
+ */
+export interface Selector_ToolNames {
+    names?: Array<string>;
+}
 /**
  * SetToolCallContentRequest lets an external API consumer supply the result
  *  of a bare tool call (one whose tool set has no execution adapter). Used
@@ -3120,6 +3400,12 @@ export interface ToolCalled {
      * The arguments passed to the tool.
      */
     arguments?: Record<string, unknown>;
+    /**
+     * Whether the runtime authorized this call's arguments to be exposed in
+     *  public widget events. This records the resolved policy at call time so
+     *  consumers do not need to re-evaluate the tool set's current overlays.
+     */
+    argumentsExposedInWidgets?: boolean;
 }
 export interface ToolDenied {
     /**
@@ -3145,9 +3431,194 @@ export interface ToolInfo {
      * Content signature identifying the tool within its tool set: a hash of the
      *  sanitized llm_tool_name, description, and canonical parameters. Two tools
      *  with the same llm_tool_name but different parameters or description (as
-     *  MCP servers may return per user) have distinct signatures.
+     *  MCP servers may return per user) have distinct signatures. Computed over
+     *  the raw spec — overlays do not change a tool's signature.
      */
     signature: string;
+    /**
+     * Keys of the tool set's overlays whose selectors match this tool
+     *  (ToolSetSpec.overlays), in evaluation order. Disabled overlays are
+     *  excluded. An overlay is listed when its selector matches even if none
+     *  of its actions changed this tool's schema (all its paths were absent),
+     *  so this answers "which policies apply to this tool" — diff
+     *  effective_parameters against spec.parameters for "what changed".
+     *  Empty when no overlay applies.
+     */
+    overlays?: Array<string>;
+    /**
+     * The parameter schema as presented to the model: spec.parameters after
+     *  every matching overlay's parameter actions have been applied, in order,
+     *  including maintenance of the schema's `required` list. Actions whose
+     *  outcome depends on the objective (pin with ON_MISSING_SKIP) are applied
+     *  as if the pinned key were present, so this reflects the intended steady
+     *  state rather than any one objective. Equals spec.parameters when no
+     *  overlay applies. Result actions have no effect here.
+     */
+    effectiveParameters?: Record<string, unknown>;
+}
+/**
+ * A tool overlay is a policy attached to a tool set that reshapes the tools
+ *  the model sees and calls. It pairs a selector (which tools it applies to)
+ *  with actions that run before a call — rewriting the tool's parameter
+ *  schema and the arguments the model supplied — and after a call —
+ *  rewriting the result before it enters the model's context. It can also
+ *  explicitly allow the final call arguments to cross the otherwise-private
+ *  widget API boundary.
+ *
+ *  Overlays exist for three reasons:
+ *
+ *    - Authority. Adapter-derived tool sets (OpenAPI especially) expose many
+ *      parameters the model must never guess — a workspace id, a tenant id,
+ *      an account scope. Overlays bind those parameters to the objective's
+ *      `pinned_parameters` (see CreateObjectiveRequest.pinned_parameters):
+ *      the parameter disappears from the schema and the value is forced
+ *      server-side, so the model has no opportunity to supply a different
+ *      one.
+ *    - Context. Large specs carry pagination cursors, expansion flags and
+ *      verbose responses that cost tokens without helping the model.
+ *      Overlays strip parameters, fix them to literals, and compact results.
+ *    - Widget presentation. Tool arguments are private by default. An overlay
+ *      can opt matching tools into exposing their final call arguments in
+ *      visitor-facing widget events so an embedding UI can select a custom
+ *      renderer or presentation.
+ *
+ *  Pinned parameters and overlays are complementary: pinned parameters are
+ *  *data* supplied per objective (or per widget session) by the caller;
+ *  overlays are *policy* authored once on the tool set. Pinning by name
+ *  still works without an overlay — a pinned key that matches a top-level
+ *  parameter name is applied to every tool in the objective — overlays are
+ *  for the cases that needs more: nested paths, renamed keys, a subset of
+ *  tools, or values that are literals rather than caller-supplied.
+ *
+ *  Evaluation model:
+ *
+ *    - Overlays are evaluated in list order; within an overlay, actions are
+ *      evaluated in list order. Later actions win on the same path (a `set`
+ *      followed by a `remove` leaves the parameter removed).
+ *    - The parameter schema the model sees is computed when tools are
+ *      assembled for an objective, so pre-call actions can consult that
+ *      objective's pinned parameters (this is what makes `pin` with
+ *      ON_MISSING_SKIP meaningful). Argument rewriting runs on every call.
+ *    - An action whose `path` does not exist in the tool's parameter schema
+ *      changes nothing in the schema the model sees. This is deliberate: a
+ *      broad selector (every `list_*` tool) may match tools with different
+ *      shapes, and one overlay should be able to cover all of them without
+ *      erroring on the ones that lack a given parameter. At call time the
+ *      model's arguments can still not widen what it controls: `remove`
+ *      strips the path whether or not it is declared, and `set`/`pin`
+ *      overwrite a value the model sent at an undeclared path (a schema this
+ *      evaluator cannot see through, e.g. behind $ref/allOf) while injecting
+ *      nothing into tools that lack the parameter.
+ *    - Overlays apply to just-in-time tool sets as well; the tools are
+ *      evaluated against overlays at the moment they are loaded.
+ *    - Result actions run once, when the tool call's result is recorded; the
+ *      stored result is the transformed one, so every reader (the model,
+ *      compaction, the API) sees the same content. They are not supported on
+ *      bare tool sets.
+ */
+export interface ToolOverlay {
+    /**
+     * Identifies the overlay within its tool set. Unique across the tool
+     *  set's overlays (enforced by the server), stable across reorders, and
+     *  surfaced in tool call messages ("parameter removed by overlay
+     *  strip-list-knobs") so an operator can trace a rewritten call back to
+     *  the policy that rewrote it. Referenced by ToolInfo.overlays and the
+     *  ListToolsRequest.overlays filter.
+     */
+    key: string;
+    /**
+     * Which tools this overlay applies to. Required; an empty selector
+     *  (no conditions) matches every tool in the set.
+     */
+    selector: ToolOverlay_Selector;
+    /**
+     * Pre-call actions, applied in order. See ParameterAction.
+     */
+    parameterActions?: Array<ToolOverlay_ParameterAction>;
+    /**
+     * Post-call actions, applied in order. See ResultAction.
+     */
+    resultActions?: Array<ToolOverlay_ResultAction>;
+    /**
+     * When true the overlay is retained in the spec but not evaluated. Lets an
+     *  operator switch a policy off to diagnose a misbehaving tool without
+     *  deleting it and losing the configuration.
+     */
+    disabled: boolean;
+    /**
+     * Arguments may carry sensitive customer data, including values injected by
+     *  parameter actions, so they stay private unless an overlay enables them.
+     *
+     *  Unset means this overlay has no opinion. When several enabled overlays
+     *  match a tool, they are evaluated in list order and the last overlay that
+     *  supplies this policy wins. If none supplies it, arguments stay private.
+     *  Disabled overlays never participate.
+     */
+    widgetArgumentExposure?: ToolOverlay_WidgetArgumentExposure;
+}
+/**
+ * A pre-call action. Parameter actions rewrite the tool's parameter
+ *  schema as presented to the model and the arguments the model supplies
+ *  when it calls the tool. Both sides are always kept in agreement: a
+ *  parameter that is hidden from the schema is also stripped from (or
+ *  forced in) the arguments, so the model can neither see nor smuggle it.
+ */
+export type ToolOverlay_ParameterAction = ToolOverlay_ParameterAction_Remove | ToolOverlay_ParameterAction_Set | ToolOverlay_ParameterAction_Pin;
+/**
+ * A dotted path into a tool's parameter schema. Each segment is a property
+ *  name; the path `filter.workspaceId` addresses
+ *  `properties.filter.properties.workspaceId` in the schema and
+ *  `arguments.filter.workspaceId` in the call. Only object properties are
+ *  addressable — there is no array indexing, wildcarding or filtering.
+ *
+ *  This is deliberately not JSONPath: every action needs a single,
+ *  unambiguous location in both the schema and the arguments so that
+ *  removing a parameter from the schema and stripping it from the call are
+ *  guaranteed to agree.
+ */
+export interface ToolOverlay_ParameterPath {
+    path: string;
+}
+/**
+ * A post-call action. Result actions rewrite a tool call's result after
+ *  the adapter returns and before it is recorded: the transformed content
+ *  is what is stored and what the model reads (ObjectiveToolCallResult
+ *  content). The adapter's raw response is kept in the tool call's debug
+ *  log for operators; it is not otherwise retained.
+ *
+ *  Result actions apply to MCP, OpenAPI and HTTP tool sets. They are not
+ *  supported on bare tool sets — a bare tool's content is supplied by an
+ *  external consumer, so there is nothing for the platform to reshape —
+ *  and a tool set whose adapter is `bare` rejects overlays that carry
+ *  result actions.
+ *
+ *  When several matching overlays carry transforms they run in overlay
+ *  order, each one reading the previous one's output.
+ */
+export type ToolOverlay_ResultAction = ToolOverlay_ResultAction_Transform;
+/**
+ * Default: OPERATOR_AND.
+ */
+export type ToolOverlaySelectorOperator = 'OPERATOR_UNSPECIFIED' | 'OPERATOR_AND' | 'OPERATOR_OR';
+/**
+ * Which tools in the tool set an overlay applies to. Conditions are
+ *  combined with `operator`; an overlay with no conditions matches every
+ *  tool in the set.
+ */
+export interface ToolOverlay_Selector {
+    conditions?: Array<Selector_Condition>;
+    /**
+     * Default: OPERATOR_AND.
+     */
+    operator: ToolOverlaySelectorOperator;
+}
+/**
+ * Controls whether matching tool calls may expose their final arguments to
+ *  visitor-facing widget events. The containing message's presence means the
+ *  overlay has an opinion; enabled selects whether that opinion is on or off.
+ */
+export interface ToolOverlay_WidgetArgumentExposure {
+    enabled: boolean;
 }
 export interface ToolResult {
     toolCallId: string;
@@ -3181,7 +3652,7 @@ export type ToolSetAdapter = ToolSetAdapter_McpVariant | ToolSetAdapter_HttpVari
  * Approval filters that will automatically set the approval requirement on tools synced from an external source
  */
 export type ToolSetAdapter_ApprovalRequirementFilter = ToolSetAdapter_ApprovalRequirementFilter_Always | ToolSetAdapter_ApprovalRequirementFilter_Only;
-export type ToolSetAdapterAttributeFilterAttribute = 'ATTRIBUTE_UNSPECIFIED' | 'ATTRIBUTE_NAME' | 'ATTRIBUTE_TITLE' | 'ATTRIBUTE_DESCRIPTION';
+export type ToolSetAdapterAttributeFilterAttribute = 'ATTRIBUTE_UNSPECIFIED' | 'ATTRIBUTE_NAME' | 'ATTRIBUTE_TITLE' | 'ATTRIBUTE_DESCRIPTION' | 'ATTRIBUTE_LLM_TOOL_NAME';
 /**
  * Single attribute filter
  */
@@ -3205,6 +3676,27 @@ export interface ToolSetAdapter_Bare {
     contentTimeout?: number;
 }
 export interface ToolSetAdapter_HTTP {
+    /**
+     * Base URL for dispatching tool calls.
+     *
+     *  May be templated. Two reference forms are supported, and they resolve
+     *  in a single pass each so neither can inject into the other:
+     *
+     *    ${SECRET_NAME}                 a workspace or tool set secret
+     *    {{ pinned_parameters.<key> }}  the objective's pinned parameters
+     *      (see CreateObjectiveRequest.pinned_parameters)
+     *
+     *  Pinned parameters are what make a per-tenant host possible: one tool
+     *  set can serve every customer of a product that assigns each of them
+     *  their own subdomain, e.g.
+     *
+     *    https://{{ pinned_parameters.tenant }}.example.com
+     *
+     *  Because the value may be a template rather than a literal URL, this
+     *  field is not constrained to a URI shape. It is validated as an
+     *  absolute http(s) URL after references are resolved, both on write
+     *  (with references stubbed) and again before each tool call.
+     */
     baseUrl?: string;
     headers?: Record<string, string>;
 }
@@ -3305,6 +3797,15 @@ export interface ToolSetSecretSpec {
 export interface ToolSetSpec {
     description?: string;
     adapter: ToolSetAdapter;
+    /**
+     * Overlays applied to this tool set's tools, evaluated in order. See
+     *  ToolOverlay. Overlay keys must be unique within the list.
+     *
+     *  As a repeated field this is replaced wholesale on update: an
+     *  update_mask of `spec.overlays` swaps the entire list for the one in the
+     *  request. Read-modify-write to add or remove a single overlay.
+     */
+    overlays?: Array<ToolOverlay>;
 }
 /**
  * ToolSetUsage describes one agent variation that uses the tool set (or, when
@@ -3339,8 +3840,9 @@ export interface ToolSpec {
      */
     parameters: Record<string, unknown>;
     /**
-     * Configuration for this specific tool. Transport/Protocol are derived from the tool set adapter, while specifics
-     *  such as endpoint, method, etc, are stored on the tool itself.
+     * Configuration for this specific tool. Its transport is derived from the
+     *  tool set adapter, while details such as endpoint and method are stored on
+     *  the tool itself.
      *
      *  Required, and exactly one adapter must be set.
      */
@@ -3427,6 +3929,11 @@ export interface UpdateAIProviderKeyRequest {
      * Fields to update.
      */
     updateMask?: string;
+    /**
+     * Field-level credential changes. This is independent of update_mask;
+     *  legacy clients may continue replacing spec.credentials atomically.
+     */
+    credentialPatch?: AIProviderCredentialPatch;
 }
 export interface UpdateAPIKeyRequest {
     /**
@@ -3577,6 +4084,41 @@ export interface UpdateMemoryLayerRequest {
     spec?: MemoryLayerSpec;
     updateMask?: string;
 }
+/**
+ * Update model request. update_mask must list leaf paths: metadata.name,
+ *  metadata.external_id, metadata.labels, spec.provider_model_id,
+ *  spec.provider, spec.family, spec.max_input_tokens, spec.max_output_tokens,
+ *  spec.capabilities, pricing_override.input_price_per_million_tokens, and
+ *  pricing_override.output_price_per_million_tokens. Synced models
+ *  (PROVENANCE_SYNCED_FROM_PROVIDER) reject metadata.name and spec.* paths.
+ *  spec price fields are never writable; price changes go through
+ *  pricing_override, where a masked-but-absent field clears the override.
+ *  Metadata and spec must be present when their respective paths are masked.
+ */
+export interface UpdateModelRequest {
+    /**
+     * Workspace ID.
+     */
+    workspaceId?: string;
+    /**
+     * Model ID. Accepts the canonical `model_…` form or the `external_id:<value>` form.
+     */
+    id?: string;
+    metadata?: UpdateResourceMetadata;
+    /**
+     * When any spec.* path is masked, send the complete spec (current values
+     *  plus edits); it is validated as a whole.
+     */
+    spec?: ModelSpec;
+    /**
+     * Customer price overrides, applied per masked path.
+     */
+    pricingOverride?: ModelPricingOverride;
+    /**
+     * Fields to update. Required; leaf paths only.
+     */
+    updateMask?: string;
+}
 /**
  * UpdateResourceMetadata contains the user-provided fields for updating
  *  a workspace-scoped resource. Read-only fields (id, account_id, workspace_id, profile_id,
@@ -3800,6 +4342,14 @@ export interface VariationMemoryLayerAssignment {
      */
     position: number;
 }
+/**
+ * VertexConfig configures the Google Cloud project and location used by the
+ *  Vertex AI backend. Both are required for service-account authentication.
+ */
+export interface VertexConfig {
+    projectId?: string;
+    location?: string;
+}
 export interface WebhookDelivery {
     metadata: OperationMetadata;
     /**
@@ -3999,13 +4549,13 @@ export interface WidgetSessionSpec {
     tokenExpiresAt?: string;
     /**
      * Parameters forced onto tool calls made by this session's conversations.
-     *  A pinned parameter is an overlay on a tool's JSON schema: the parameter
-     *  is removed from what the LLM sees, and its value is always overwritten
-     *  server-side with the pinned value — so the model cannot be tricked into
-     *  calling a tool with a different id than the one the session was minted
-     *  for (e.g. pin "workspaceId" for an OpenAPI tool with a
-     *  /workspaces/{workspaceId} path). Flows to every objective the session
-     *  creates.
+     *  A pinned parameter is removed from the tool schema the LLM sees, and its
+     *  value is always overwritten server-side with the pinned value — so the
+     *  model cannot be tricked into calling a tool with a different id than the
+     *  one the session was minted for (e.g. pin "workspaceId" for an OpenAPI
+     *  tool with a /workspaces/{workspaceId} path). Flows to every objective
+     *  the session creates. See ToolSetSpec.overlays for binding pinned keys to
+     *  nested or differently named parameters.
      */
     pinnedParameters?: Record<string, string>;
 }
@@ -4239,6 +4789,17 @@ export interface ToolSetAdapter_OpenAPI_Url {
     /**
      * Base URL for dispatching tool calls. If set, overrides the server
      *  resolved from the spec's servers array.
+     *
+     *  May be templated with the same two reference forms the HTTP adapter's
+     *  base_url accepts:
+     *
+     *    ${SECRET_NAME}                 a workspace or tool set secret
+     *    {{ pinned_parameters.<key> }}  the objective's pinned parameters
+     *
+     *  A spec written against a single host can therefore be dispatched to a
+     *  per-tenant one, e.g. https://{{ pinned_parameters.tenant }}.example.com,
+     *  without cloning the tool set per customer. Validated as an absolute
+     *  http(s) URL after references are resolved rather than as a literal URI.
      */
     baseUrl?: string;
     /**
@@ -4265,6 +4826,17 @@ export interface ToolSetAdapter_OpenAPI_UploadId {
     /**
      * Base URL for dispatching tool calls. If set, overrides the server
      *  resolved from the spec's servers array.
+     *
+     *  May be templated with the same two reference forms the HTTP adapter's
+     *  base_url accepts:
+     *
+     *    ${SECRET_NAME}                 a workspace or tool set secret
+     *    {{ pinned_parameters.<key> }}  the objective's pinned parameters
+     *
+     *  A spec written against a single host can therefore be dispatched to a
+     *  per-tenant one, e.g. https://{{ pinned_parameters.tenant }}.example.com,
+     *  without cloning the tool set per customer. Validated as an absolute
+     *  http(s) URL after references are resolved rather than as a literal URI.
      */
     baseUrl?: string;
     /**
@@ -4275,6 +4847,48 @@ export interface ToolSetAdapter_OpenAPI_UploadId {
      */
     serverName?: string;
 }
+export interface Selector_Condition_Attribute {
+    type: 'attribute';
+    /**
+     * Match on a tool attribute (name, title, description,
+     *  llm_tool_name) with a string matcher — the same filter used by
+     *  the adapter's include/exclude lists.
+     */
+    attribute: ToolSetAdapter_AttributeFilter;
+}
+export interface Selector_Condition_HasParameter {
+    type: 'hasParameter';
+    /**
+     * Match tools whose parameter schema contains the given path. This
+     *  is the usual way to target "every tool that takes a workspaceId"
+     *  without enumerating tools by name.
+     */
+    hasParameter: ToolOverlay_ParameterPath;
+}
+export interface Selector_Condition_Tools {
+    type: 'tools';
+    /**
+     * Match specific tools by LLM tool name. The direct way to assign an
+     *  overlay to one tool (or a handful) without writing a matcher.
+     */
+    tools: Selector_ToolNames;
+}
+export interface ToolOverlay_ParameterAction_Remove {
+    type: 'remove';
+    remove: ParameterAction_Remove;
+}
+export interface ToolOverlay_ParameterAction_Set {
+    type: 'set';
+    set: ParameterAction_Set;
+}
+export interface ToolOverlay_ParameterAction_Pin {
+    type: 'pin';
+    pin: ParameterAction_Pin;
+}
+export interface ToolOverlay_ResultAction_Transform {
+    type: 'transform';
+    transform: ResultAction_Transform;
+}
 export interface ToolSpec_Config_Http {
     type: 'http';
     http: Config_HTTP;
@@ -4478,6 +5092,22 @@ export interface AIProviderCredential_Headers {
      */
     headers: CredentialHeaders;
 }
+export interface AIProviderCredential_GoogleServiceAccount {
+    type: 'googleServiceAccount';
+    /**
+     * Google service-account JSON for Vertex AI. The server accepts only the
+     *  service_account credential type and never writes the JSON to plaintext
+     *  storage.
+     */
+    googleServiceAccount: CredentialGoogleServiceAccount;
+}
+export interface AIProviderCredential_AwsAccessKey {
+    type: 'awsAccessKey';
+    /**
+     * AWS access credentials for Bedrock SigV4 authentication.
+     */
+    awsAccessKey: CredentialAWSAccessKey;
+}
 export interface AIProviderConfig_Openrouter {
     type: 'openrouter';
     openrouter: OpenRouterConfig;
@@ -4490,6 +5120,14 @@ export interface AIProviderConfig_OpenaiCompatible {
     type: 'openaiCompatible';
     openaiCompatible: OpenAICompatibleConfig;
 }
+export interface AIProviderConfig_Vertex {
+    type: 'vertex';
+    vertex: VertexConfig;
+}
+export interface AIProviderConfig_Bedrock {
+    type: 'bedrock';
+    bedrock: BedrockConfig;
+}
 export interface ModelSpec_Capability_Temperature {
     type: 'temperature';
     temperature: Capability_Temperature;
@@ -4598,13 +5236,13 @@ export interface WidgetSessionSpecParam {
     expiresAt?: string;
     /**
      * Parameters forced onto tool calls made by this session's conversations.
-     *  A pinned parameter is an overlay on a tool's JSON schema: the parameter
-     *  is removed from what the LLM sees, and its value is always overwritten
-     *  server-side with the pinned value — so the model cannot be tricked into
-     *  calling a tool with a different id than the one the session was minted
-     *  for (e.g. pin "workspaceId" for an OpenAPI tool with a
-     *  /workspaces/{workspaceId} path). Flows to every objective the session
-     *  creates.
+     *  A pinned parameter is removed from the tool schema the LLM sees, and its
+     *  value is always overwritten server-side with the pinned value — so the
+     *  model cannot be tricked into calling a tool with a different id than the
+     *  one the session was minted for (e.g. pin "workspaceId" for an OpenAPI
+     *  tool with a /workspaces/{workspaceId} path). Flows to every objective
+     *  the session creates. See ToolSetSpec.overlays for binding pinned keys to
+     *  nested or differently named parameters.
      */
     pinnedParameters?: Record<string, string>;
 }