Skip to content

configuration.md

Latest commit

 

History

History
590 lines (481 loc) · 32.4 KB

configuration.md

File metadata and controls

590 lines (481 loc) · 32.4 KB
Raw

Configuration reference

The agents.yaml schema. Every field below is sourced from the Zod schema in packages/sdk/src/internal/parser/schema.ts and the config types in packages/sdk/src/internal/types/config.ts. For a tutorial, see Configure an agent.

Top-level structure

version: "1"
providers:    { <name>: <provider-config> }
defaults:
  provider: <name> | "all"
  identity: <identity-name>
environments: { <name>: EnvironmentDecl }
tunnels:      { <name>: TunnelDecl }
vaults:       { <name>: VaultDecl }
memory_stores:{ <name>: MemoryStoreDecl }
skills:       { <name>: SkillDecl }
files:        { <name>: FileDecl }
identities:   { <name>: IdentityDecl }
agents:       { <name>: AgentDecl }
channels:     { <name>: ChannelDecl }
deployments:  { <name>: DeploymentDecl }
Field Type Required Description
version string yes Schema version. Currently "1".
providers map yes One block per provider; each holds its credentials.
defaults.provider string no Default target for plan/apply. all targets every declared provider.
defaults.identity string no Logical name of the default declared Identity used by identity-aware resources and Forward Sessions.
environments map no Cloud runtimes.
tunnels map no Existing Qoder BYOC tunnels referenced by sessions; OpenCMA does not manage their lifecycle.
vaults map no Credential stores.
memory_stores map no Persistent agent context (Bailian, Qoder, Claude beta, Volcengine Ark).
skills map no Reusable capability modules.
files map no Local files uploaded to the Files API (Bailian, Volcengine Ark).
identities map no Stable end-user identities. Provider support is capability-gated.
agents map no The core managed-agent resources.
channels map no External messaging channels bound to an Identity and Agent. Provider support is capability-gated.
deployments map no Repeatable run units.

Secrets use ${VAR_NAME} and resolve from .env (walking up to the project root). agents init appends agents.state.json and .env to .gitignore.

Identity

Managed identities use the integrating product's stable end-user id:

identities:
  chen:
    provider: qoder
    external_id: user_456
    name: Chen
    enabled: true
    metadata:
      department: engineering

agents apply creates or updates the remote Identity and stores its provider id in state. To reference an Identity managed outside this project, use the mutually exclusive external-reference form:

identities:
  chen:
    provider: qoder
    identity_id: idn_019eabc123

External references are verified and recorded but never updated or deleted.

Channel

channels:
  support-dingtalk:
    provider: qoder                 # optional; inherits defaults.provider
    agent: support-agent            # required for mode: fixed; ignored for mode: pairing
    identity: chen                  # optional; inherits defaults.identity. ignored for mode: pairing
    type: dingtalk
    mode: fixed                     # optional; defaults to fixed
    name: Support DingTalk          # optional; defaults to the YAML key
    enabled: true                   # optional; defaults to true
    credentials:
      client_id: ${DINGTALK_CLIENT_ID}
      client_secret: ${DINGTALK_CLIENT_SECRET}
    options:
      include_tool_calls: false
      include_thinking: false
Field Type Required Description
provider string no Provider name; inherits defaults.provider.
agent string conditional Logical Agent name. Required for fixed mode; ignored for pairing mode.
identity string conditional Logical Identity name; inherits defaults.identity. Required for fixed mode; ignored for pairing mode.
type string yes Provider-specific channel type. Qoder supports dingtalk, feishu, and wecom; wechat is QR-only.
mode fixed | pairing no fixed (default) binds the channel to one Identity/Template. pairing creates a transport-only channel for Schedules/Sinks.
name string no Display name; defaults to the YAML key.
enabled boolean no Defaults to true.
credentials map conditional Provider-specific credentials. Required for credential-based channel types.
options map no Provider-specific response options, e.g. include_tool_calls, include_thinking.

The declaration intentionally uses logical agent and identity references. Provider adapters resolve remote ids and map type, credentials, and options to provider wire fields. Qoder Channels in fixed mode require the referenced Agent to use Forward delivery. pairing mode omits Identity/Template binding and is intended for Schedule sinks such as scheduled group broadcasts. Credential-based Qoder support currently covers DingTalk, Feishu, and WeCom; personal WeChat remains QR-only.

Managed tool config

managed_tool_config declares the provider-operated tools an Agent Harness runs itself, rather than tools the model calls through the sandbox. Schedule management is the current use: enabling create_forward_schedule, list_forward_schedules, and delete_forward_schedule lets an end user create and cancel Schedules in natural language from a Web or IM Channel conversation.

enabled_tools replaces the provider's whole enabled set, so an empty array turns every managed tool off. Omitting the field entirely sends nothing: because Qoder Forward Template updates are merge-style, an undeclared field leaves whatever the remote Template already had. Declare it whenever the tools matter — a Template recreated from scratch (after a destroy, a manual deletion, or lost state) otherwise comes back with no managed tools and no error.

Provider configuration

Each provider under providers is validated by the provider's own config schema.

Bailian (Aliyun AgentStudio)

Field Type Required Description
api_key string yes DashScope API key.
workspace_id string yes Bailian workspace id (llm-...).
base_url string no Override the derived endpoint (https://<workspace_id>.cn-beijing.maas.aliyuncs.com/api/v1/agentstudio).

Qoder

Field Type Required Default Description
api_key string yes — Qoder PAT.
gateway string no https://api.qoder.com/api/v1/cloud Cloud gateway base URL.

Claude

Field Type Required Description
api_key string yes Anthropic API key.
beta string no Optional anthropic-beta header value.

Volcengine Ark (Managed Agents)

Field Type Required Description
api_key string yes Volcengine Ark API key.

Environment

environments:
  <name>:
    name: <string>            # optional
    description: <string>     # optional
    provider: <string>       # optional; pin to one provider
    environment_id: <string> # optional; reference an existing provider environment without managing it
    config:
      type: cloud | self_hosted
      networking: { ... }
      packages: { ... }
      setup_script: <string>
    metadata: { <key>: <string> }
Field Type Required Description
environment_id string no Existing environment ID. When present, OpenCMA never creates, updates, or deletes the remote environment. Removing this line later is blocked as an ownership error — release first with agents state rm (see Use BYOC environments).
config.type "cloud" | "self_hosted" yes Environment type. self_hosted is used for Qoder BYOC.
config.networking.type "unrestricted" | "limited" no Network policy.
config.networking.allow_mcp_servers boolean no Allow outbound MCP.
config.networking.allow_package_managers boolean no Allow package managers.
config.networking.allowed_hosts string[] no Allow-list for limited networks.
config.packages.apt | pip | npm | cargo | gem | go string[] no Preinstalled packages.
config.setup_script string no Sandbox setup script. Qoder runs it with /bin/bash -lc after package installation; maximum UTF-8 size is 64 KB. Other providers currently reject this field.
metadata map<string,string> no Free-form metadata.

Qoder accepts only apt, npm, and pip in package requests. Its API may return empty cargo, gem, and go arrays as reserved response fields, but declaring non-empty values for them is rejected locally. Setup scripts run while a new sandbox is prepared, time out after 10 minutes, and a non-zero exit prevents the Session from starting. Keep scripts idempotent and use vault-backed credentials instead of embedding secrets.

For a managed Qoder self_hosted environment, config accepts only type and optional setup_script; networking and packages belong to cloud environments. External environment_id references remain unmanaged.

Tunnel (Qoder BYOC)

tunnels:
  internal-network:
    tunnel_id: tnl_00xxxx

Tunnels are existing Qoder resources allocated by the BYOC administrator. They are passed only when a Qoder session/deployment is created and are never created, updated, or deleted by OpenCMA. See Use BYOC environments for a complete setup and lifecycle guide.

Vault

vaults:
  <name>:
    display_name: <string>
    provider: <string>          # optional
    credentials: [ CredentialDecl ]
    metadata: { <key>: <string> }

CredentialDecl is a discriminated union on type:

static_bearer

Field Type Required Description
name string yes Credential name.
type "static_bearer" yes
mcp_server_url string yes MCP server URL.
access_token string yes Bearer token (string or number, coerced).
protocol "sse" | "streamable_http" no MCP transport.

environment_variable

Field Type Required Description
name string yes Credential name.
type "environment_variable" yes
secret_name string yes Secret name.
secret_value string yes Secret value (string or number, coerced).
networking.type "unrestricted" | "limited" no Legacy policy type. Bailian requests use allowed_hosts instead.
networking.allowed_hosts string[] no Bailian credential injection host allow-list, e.g. ["api.example.com", "*.example.org"]; ["*"] allows all hosts.
injection_location.header boolean no Bailian: allow secret replacement in request headers.
injection_location.body boolean no Bailian: allow secret replacement in request bodies.

For Bailian, these fields are nested under auth in credential create/update requests. When omitted, creation uses networking: { allowed_hosts: ["*"] } and injection_location: { header: true, body: false }. Legacy networking.type: unrestricted maps to ["*"]; limited must include allowed_hosts and is never widened implicitly. Explicit host lists and injection booleans are preserved, including through sync/export. Credential retry adoption compares host sets and injection policy as well as the existing identity and metadata fields; a different policy is not treated as an exact match.

Memory store

memory_stores:
  <name>:
    name: <string>             # optional display name; defaults to the logical key
    description: <string>
    provider: <string>          # optional
    metadata: { <string>: <JSON-value> } # optional; Bailian preserves JSON values
    entries_mode: initialize    # optional; initialize (default) | sync
    entries: [ { key: <string>, content: <string> } ]

Supported on Bailian, Qoder, Claude (beta), and Volcengine Ark.

By default, entries initialize a newly created store only. Existing, imported, or adopted stores keep their memory content: later apply runs update store attributes without creating, updating, or deleting memory files. Changing the initial entries alone does not schedule a store update.

Set entries_mode: sync explicitly to keep declared paths managed by YAML. Sync creates or updates those paths while preserving additional memories written by agents; removing an entry does not delete its remote file. Runtime CRUD and version commands are documented in examples/memory/.

默认只在新库创建时写入 entries；已有、导入或接管的库保留正文。仅修改初始化内容不会触发库更新。 需要持续同步声明路径时，显式设置 entries_mode: sync。

Bailian lifecycle

The YAML key is a project reference; name is a display label, not a unique remote identity. A missing State ID always creates a new store, even if another store has the same display name. To manage an existing store, explicitly import its remote ID. Import validates that the store exists and is active, rejects an ID already bound to another State address, and does not initialize its contents.

Bailian manages the store's display name, description, and only the metadata keys declared in YAML. Before updating metadata, apply reads the store and merges the declared keys into its current metadata, preserving keys added remotely. Runtime file contents and server-generated counters are not treated as store-attribute drift. When entries_mode: sync is explicitly enabled, refresh also compares the SHA-256 of declared paths so remote edits or deletions schedule reconciliation. Other paths are ignored, and State stores only hashes, not memory bodies.

For a new store, apply saves the returned ID and each pending initializer's path and content SHA-256 to State before writing any entries; it does not save the entry bodies in State. If initialization fails, rerun apply with the original pending entries. It resumes only unfinished paths in the same store, preserves any path that already exists, and checkpoints each completed path. Changing or removing a pending initializer is rejected; restore its original content to resume. Sessions cannot mount a store while this initialization is incomplete.

Removing a Bailian store from YAML and applying, or running destroy, archives that store. Archiving is irreversible; it is not an unbind operation. Reusing the logical name after removal creates a new remote store.

百炼通过 State 中的远端 ID 识别库，不按同名接管；新库初始化失败后沿用已保存的 ID， 只补未完成且尚不存在的路径。移除声明后 apply 或执行 destroy 会不可逆地归档记忆库。

Skill

skills:
  <name>:
    source: <string>           # path to skill directory
    description: <string>      # optional
    version: <string>         # optional
    origin: "custom" | "official"   # optional
    provider: <string>        # optional

File

files:
  <name>:
    source: <string>
    name: <string>            # optional
    purpose: <string>         # optional
    provider: <string>         # optional

Declarative uploads use the basename of source, preserving its extension. name is an optional local label, not an upload filename override. For example, source: ./reference.md with name: Assistant Reference uploads as reference.md. 文件上传使用 source 的原始文件名（含扩展名）；name 仅作为本地名称，不覆盖上传文件名。

Agent

agents:
  <name>:
    description: <string>
    model: <string> | { <provider>: <string> }
    instructions: <string> | <path>
    environment: <string>
    tunnel: <string>              # optional; Qoder BYOC tunnel name
    provider: <string>
    tools: { builtin: [...], default_permission: allow, mcp: [...], permissions: {...} }
    mcp_servers: [ { name, type?, url? } ]
    skills: [ <string> | { type, skill_id, version? } ]
    vault: <string>
    memory_stores: [ <string> ]
    files: [ { file: <string>, mount_path: <string> } ]
    default_memory_store:             # Qoder Forward only; requires defaults.identity
      name: <string>                  # 1-255 characters
      description: <string>           # optional; up to 1024 characters
      delete_on_destroy: <boolean>    # optional; defaults to false (retain)
    environment_variables: { <key>: <string> }  # Qoder only
    managed_tool_config: { enabled_tools: [ <string> ] }  # Qoder Forward delivery only
    delivery:                     # optional; per-provider remote materialization
      qoder:
        type: managed | forward
    resources: [ SessionResource ]
    multiagent: { type: "coordinator", agents: [...] }
    metadata: { <key>: <string> }

Qoder Forward default Memory Store

Qoder creates one writable, system-managed Memory Store for an (Identity, Template) pair when its first Forward Session is created. default_memory_store lets OpenCMA manage the display metadata and destroy policy of that provider-created Store; it does not declare a second, ordinary entry under the top-level memory_stores collection.

defaults:
  provider: qoder
  identity: support-user

identities:
  support-user:
    external_id: support-user       # managed by OpenCMA

agents:
  support:
    # ...
    delivery:
      qoder:
        type: forward
    default_memory_store:
      name: "Support group memory"
      description: "Confirmed support knowledge and operating rules"
      delete_on_destroy: false

Apply behavior:

  • Requires Qoder Forward delivery and defaults.identity.
  • Locates the Store mounted as system_managed: true and access: read_write, then idempotently updates its name and optional description.
  • Does not create an initialization Session. Before the first real Session has created the Store, apply reports the reconciliation as pending. Run apply again after a Session exists.
  • name changes the provider Store's display name, so it can be meaningful instead of remaining the provider-generated default.

Destroy behavior:

delete_on_destroy Result
omitted or false Retain the Store, its Memories, and all version history. This is the default.
true Permanently delete the Store, its Memories, and all version history after its system mount has been removed.

For permanent deletion, OpenCMA captures and persists the Store ID before archiving the Template and deleting the Identity. Qoder may remove the system mount asynchronously, so OpenCMA uses bounded retries for a still mounted conflict. If the conflict remains, it tries archive → delete, matching the lifecycle verified against the live Qoder service. A cleanup that still cannot finish is retained in state and reported as a partial destroy; a later agents destroy resumes it even when all ordinary resources are already gone.

If the preflight cannot resolve the Identity, Template, or Store lookup, destroy aborts before deleting any project resource. Authentication, permission, and non-retryable validation errors fail immediately. --cascade does not override this field.

delete_on_destroy: true requires an OpenCMA-managed Identity. An external identity_id is never deleted by OpenCMA, so it keeps the system Store mounted and fails configuration validation. Permanent deletion is irreversible; keep the default false unless data removal is explicitly required.

Field Type Required Description
model string | map<provider,string> yes Single model or a per-provider map.
instructions string yes Inline text or a path to a file (resolved relative to the config).
environment string no Environment name.
tunnel string no Qoder BYOC tunnel name from tunnels; unsupported for other providers.
provider string no Pin the agent to one provider.
files (string | { file, mount_path })[] no String references are inherited by Qoder Forward Templates; objects mount declared top-level Files into every new Session. file is the logical File name; the path is normalized under the provider mount root.
tools.builtin string[] yes (in tools) Lowercase tool names.
tools.default_permission "allow" | "ask" no Permission inherited by enabled builtins; defaults to allow.
tools.permissions map<string,"allow"|"ask"> no Case- and separator-insensitive overrides for enabled builtins. Unknown and duplicate normalized names are rejected.
tools.mcp[] McpToolkitDecl[] no Select tools from an official MCP server.
mcp_servers[] { name, type?, url? } no URL (url/http) or official MCP server.
skills[] string | AgentSkillRef no Skill name or { type: "official"|"custom", skill_id, version? }.
vault string no Vault name.
files string[] no File declarations inherited by a Qoder Forward Template. These files are created through the Forward File API.
memory_stores string[] no Logical names of bound memory stores. Bailian resolves them through State and mounts them read-write in each Session.
default_memory_store.name string yes (with default_memory_store) Display name for Qoder Forward's writable system-managed Store; 1–255 characters.
default_memory_store.description string no Display description for the system-managed Store; up to 1024 characters.
default_memory_store.delete_on_destroy boolean no Permanently delete the Store during destroy. Defaults to false (retain).
environment_variables map<string,string> no Qoder runtime variables. Managed Sessions use Qoder's KEY=VALUE;... wire format; Forward Templates store the map as defaults and Forward Sessions send it under config.environment_variables.
managed_tool_config.enabled_tools string[] no Provider-operated tools the Agent Harness exposes, e.g. create_forward_schedule, list_forward_schedules, delete_forward_schedule. Qoder Forward delivery only; declaring it on managed delivery is a validation error.
delivery.<provider>.type "managed" | "forward" no Per-provider remote materialization. Omitted means the managed Agent resource. forward (Qoder only) materializes the agent as a Forward Template; Qoder multi-agent members must use the same delivery type as their coordinator.
resources SessionResource[] no Resources attached to every managed Session created for the Agent.
multiagent.type "coordinator" no Declare a coordinator agent.
multiagent.agents (string | { agent_id: string })[] yes (with multiagent) Project logical names and, for Managed delivery, explicitly referenced external Agent ids.
metadata map<string,string> no Free-form metadata.

For Qoder Forward delivery, a locally declared Environment is created only through the Forward Environment API. An external environment_id may reference an Environment from either the Managed API or the Forward API; OpenCMA does not create or mutate such a reference and resolves its API domain when checking existence. Referenced custom Skills, Vaults and Credentials, Files, and explicit Memory Stores are created through their Forward APIs. A locally managed Environment, Skill, Vault, File, or Memory Store cannot be shared by Managed and Forward Agents under one logical declaration; declare separate resources for the two API domains. Explicit Forward Memory Stores require defaults.identity and are mounted read-only to that Identity and Template.

Multi-agent

A coordinator agent can orchestrate project-owned agents and existing external Managed Agents:

agents:
  researcher: { ... }
  writer: { ... }
  lead:
    model: <model>
    instructions: |
      You are the lead agent coordinating a team: ...
    multiagent:
      type: coordinator
      agents:
        - researcher
        - writer
        - agent_id: agent_external_reviewer

Phase 1 rules, enforced at plan time on every provider:

  • A string member is a project logical name. OpenAgentPack resolves it to the materialized remote resource and manages its lifecycle.
  • { agent_id: ... } explicitly references an external Managed Agent. It does not need a local agents declaration or state entry and OpenAgentPack never creates, updates, or destroys it.
  • Qoder Forward does not accept { agent_id }, because its roster requires Template ids. External Forward Templates are not exposed by the common schema yet.
  • For project logical-name members, self references, nested coordinators, and any direct or indirect cycle are rejected. External members are non-owned leaves in the topology.
  • A roster carries at most 20 members (Qoder and Bailian platform limits).
  • On Qoder, every member must use the same delivery type as its coordinator: a managed coordinator references managed Agents (by id), a forward coordinator references Forward Templates (by template_id).

Version semantics per materialization (OpenAgentPack never declares member versions):

  • Qoder Managed: the member reference carries only id; the platform pins each member's current numeric version when the coordinator is saved.
  • Qoder Forward: the member reference carries only template_id; there is no member version field — members always run the Template's current content.
  • Bailian: the member reference carries only id; the child Thread resolves the latest member version when it is first created and keeps that version for its lifetime.

Update and clear semantics are hidden by the provider adapters: removing multiagent from a coordinator declaration clears the remote roster on update (Qoder sends an explicit multiagent: null, Bailian sends an empty array) — you never write provider-specific clear payloads yourself. Whether delegation actually happens is decided by the coordinator's system prompt and the runtime, so describe task split, delegation criteria, and output format in instructions.

Bailian child agents run in parallel over a shared file system: files written by one member are visible to the others. Declare file/directory ownership in the coordinator's instructions (and in each member's) to keep parallel members from writing the same path.

self references, Qoder Advisors, explicit member versions, external Forward Templates, and Thread management are not exposed by the common schema yet.

agents sync reverse-maps project-owned members to logical names via the agents.project/agents.resource metadata OpenAgentPack injects, and preserves non-owned members as { agent_id }. The sync fails closed — without touching your existing file — when a project-owned roster member is archived, missing from the account listing, lacks a logical name, or when two remote agents claim the same logical name.

Session resources

Bailian managed Sessions support Memory Store resources. Both forms below reference top-level memory_stores by their logical YAML key:

agents:
  assistant:
    # ...
    memory_stores: [notes] # shorthand: read_write
    resources:
      - type: memory_store
        memory_store: notes
        access: read_only # optional; read_write by default
        instructions: Use prior project decisions when answering. # optional

The explicit resource overrides shorthand settings for the same remote store, so the example mounts notes once with read-only access. Duplicate explicit mounts are rejected, and a Bailian Session can mount at most eight distinct stores. Each reference must resolve to an applied or imported State ID for the same provider. instructions is limited to 4096 characters. The server chooses the mount path; do not declare mount_path on a Memory resource. The SDK sends resources[].memory_store_id, access, and optional instructions, and preserves server-returned resources and mount paths in Session details.

Qoder and Claude managed Sessions support a provider-neutral GitHub repository resource:

agents:
  reviewer:
    # ...
    resources:
      - type: github_repository
        url: https://github.com/acme/private-repo.git
        authorization_token: ${GITHUB_TOKEN}
        checkout: { branch: main } # or: { commit: <full-sha> }
        mount_path: /data/workspace/private-repo # optional

Keep authorization_token in .env; never put its value directly in agents.yaml. Qoder mount paths must start with /data/. If the field is omitted for Qoder, OpenAgentPack sends /data/workspace/<repo-name> automatically; for the URL above that is /data/workspace/private-repo. Qoder requires this /data path for the repository mount to take effect. Other providers retain their own path semantics.

Mount roots are provider invariants: Qoder uses /data, Claude uses /workspace, and Bailian and Ark use /mnt. A relative uploaded-file path is resolved under the target root. An explicit absolute path must already use the matching root and is passed through unchanged; OpenAgentPack rejects mismatched absolute paths instead of silently rewriting them. For GitHub Session resources, when the path is omitted Qoder derives /data/workspace/<repo-name> and Claude derives /workspace/<repo-name>.

MCP toolkit (tools.mcp[])

configs is optional. On Bailian, omit it (or use configs: []) to apply default_config.enabled to every tool in the server. Set it to true to enable all tools without listing tool names. If default_config is also omitted, the default remains false. Use configs only for per-tool overrides:

tools:
  builtin: [read]
  mcp:
    - type: mcp_toolkit
      mcp_server_name: WebSearch      # mcpServerName also accepted
      default_config: { enabled: false }   # defaultConfig also accepted
      configs:
        - name: bailian_web_search
          enabled: true

Deployment

deployments:
  <name>:
    agent: <string>
    agent_version: <number>           # optional
    environment: <string>             # optional
    tunnel: <string>                  # optional; Qoder BYOC only (see note below)
    vaults: [ <string> ]
    memory_stores: [ <string> ]
    resources: [ DeploymentResource ]
    environment_variables: { <key>: <string> } # optional; Bailian string map
    initial_events: [ InitialEvent ]  # 1..50
    schedule: { expression: <cron>, timezone: <tz> }
    description: <string>
    provider: <string>
    metadata: { <key>: <string> }

initial_events is a discriminated union; schedule.expression must be a 5-field cron expression.

For Bailian, environment_variables is a map of string keys and string values, such as { REPORT_REGION: "cn-hangzhou", FEATURE_ENABLED: "true" }. The reserved map key __proto__ is not supported. These variables are available by name in the deployment-run sandbox. Changes are reconciled by plan/apply; removing the field or declaring {} sends an empty map on the next update to clear the deployment variables. For Qoder, the field retains its existing string format, such as "REPORT_REGION=cn-hangzhou;FEATURE_ENABLED=true". Claude and Ark do not support this field.

Deployment tunnel caveat: Qoder's deployment API does not accept tunnel_id, so the tunnel is dropped from the deployment payload and server-side runs execute without it (validate/plan emits a warning). Use sessions for private-network MCP access; see Use BYOC environments.

Initial events

Type Fields
user.message content
system.message content
user.define_outcome description?, rubric? | rubric_file?, max_iterations? (int 1–20)

Deployment resources

Type Fields
file file_id?, source?, mount_path?
memory_store memory_store, access? (read_write|read_only), instructions?
github_repository url, checkout? (branch/commit), mount_path?, authorization_token?

This table describes the cross-provider schema. Bailian Deployment resources accept files only, with a required mount_path. Memory mounting through Deployment memory_stores, explicit memory_store resources, or the referenced Agent's inherited Memory bindings is a validation error. Create a Session to mount Memory Stores. GitHub repository resources produce a warning and are not sent in the Bailian Deployment payload.