@cadenya/cadenya 1.0.1 → 1.1.0

package/src/types.ts

@@ -10,16 +10,52 @@
 export type AIProviderConfig =
   | AIProviderConfig_Openrouter
   | AIProviderConfig_Openai
-  | AIProviderConfig_OpenaiCompatible;
+  | 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;
+  | 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.
@@ -38,6 +74,11 @@ 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.
@@ -56,12 +97,21 @@ 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 {
   /**
@@ -75,8 +125,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;
 }
@@ -442,7 +493,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';
 
@@ -460,9 +511,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.
@@ -637,10 +688,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;
 }
@@ -658,7 +707,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;
   /**
@@ -825,11 +874,18 @@ 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).
@@ -1197,6 +1253,26 @@ export interface CreateMemoryLayerRequest {
   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
  */
@@ -1278,9 +1354,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>;
 }
@@ -1442,6 +1521,24 @@ 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": "..."}).
@@ -1532,7 +1629,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;
 }
@@ -1645,11 +1742,6 @@ export interface ListObjectiveFeedbackResponse {
   pagination?: Page;
 }
 
-export interface ListObjectiveTasksResponse {
-  items: Array<ObjectiveTask>;
-  pagination?: Page;
-}
-
 export interface ListObjectiveToolCallsResponse {
   items: Array<ObjectiveToolCall>;
   pagination?: Page;
@@ -1993,6 +2085,13 @@ export interface MemoryReference {
  */
 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
@@ -2012,6 +2111,40 @@ 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;
 }
 
 /**
@@ -2036,6 +2169,22 @@ 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")
@@ -2054,11 +2203,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;
   /**
@@ -2067,6 +2221,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;
 }
 
 /**
@@ -2086,7 +2249,7 @@ export type ModelSpec_Capability =
 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
@@ -2259,10 +2422,10 @@ export interface ObjectiveContextWindowInfo {
 }
 
 /**
- * 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 {
   /**
@@ -2465,34 +2628,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
@@ -2580,6 +2715,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>;
 }
 
@@ -2632,6 +2773,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;
 }
 
 /**
@@ -2770,6 +2916,82 @@ 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.
  */
@@ -2934,6 +3156,67 @@ 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.
  */
@@ -3039,6 +3322,26 @@ export interface SearchToolsOrToolSetsResponse {
   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
@@ -3405,6 +3708,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 {
@@ -3433,9 +3742,205 @@ 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 {
@@ -3481,7 +3986,7 @@ 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
@@ -3508,6 +4013,27 @@ export interface ToolSetAdapter_Bare {
 }
 
 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>;
 }
@@ -3632,6 +4158,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>;
 }
 
 /**
@@ -3668,8 +4203,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.
    */
@@ -3766,6 +4302,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 {
@@ -3925,6 +4466,42 @@ export interface UpdateMemoryLayerRequest {
   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,
@@ -4165,6 +4742,15 @@ 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;
   /**
@@ -4374,13 +4960,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>;
 }
@@ -4647,6 +5233,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;
   /**
@@ -4674,6 +5271,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;
   /**
@@ -4685,6 +5293,55 @@ 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;
@@ -4923,6 +5580,24 @@ 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;
@@ -4938,6 +5613,16 @@ export interface AIProviderConfig_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;
@@ -5073,13 +5758,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>;
 }