Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

38.6 KB
Raw Blame
# OpenBot, on any Kubernetes cluster.
#
# THE DEFAULTS ARE WHAT A PLAIN CLUSTER CAN DO. Every place the clouds genuinely differ is a value,
# and its default is whatever a self-hosted cluster with no cloud features does: the cluster's own
# default StorageClass, no RuntimeClass, a plain Kubernetes Secret, bundled PostgreSQL, an Ingress.
# A deployment on EKS, GKE or AKS turns things on; a self-hosted one changes nothing and still works.
# There is no cloud branching anywhere in the templates, and there should never be: a chart that only
# installs cleanly on a managed cluster has failed the thing this repository is for.

nameOverride: ""
fullnameOverride: ""

image:
  repository: ghcr.io/copilotkit/openbot
  # Empty means the chart's appVersion prefixed with `v` (the form published tags take), so an
  # upgrade of the chart moves the image with it. A value set here is used verbatim.
  tag: ""
  # The image digest, `sha256:` and 64 hex characters, from the release's `container-images.json`.
  # Set, the image becomes `repository:tag@digest` and Kubernetes pulls exactly those bytes, which is
  # how docs/releasing.md says to deploy: a tag can be moved, a digest cannot. The tag stays in the
  # reference for whoever reads it. Empty pulls by tag alone, as before.
  digest: ""
  pullPolicy: IfNotPresent
imagePullSecrets: []

server:
  replicaCount: 2
  # Two by default because horizontal is the point. Everything that has to survive a replica is in
  # PostgreSQL, and one replica hides every bug that is not.

  # THE BROWSER IS NOT IN THIS POD. The image runs a Bot's computer beside the API for the
  # one-container case; a replica of the API must not carry one, because a browser is a few hundred
  # megabytes holding one Bot's logins, and scaling the API would scale those with it.
  embeddedComputer: false

  resources:
    requests:
      cpu: 250m
      memory: 512Mi
    limits:
      memory: 2Gi

  # Off by default. Turn it on and set the metric you actually want to scale on.
  autoscaling:
    enabled: false
    minReplicas: 2
    maxReplicas: 10
    targetCPUUtilizationPercentage: 70
    targetMemoryUtilizationPercentage: null
    behavior: {}

  podDisruptionBudget:
    enabled: true
    minAvailable: 1
    maxUnavailable: null

  # Spread replicas so a node or zone going away does not take the deployment with it. Soft by
  # default: a single-node cluster still schedules, which is what a first `helm install` runs on.
  topologySpreadConstraints: []
  podAntiAffinity: soft

  nodeSelector: {}
  tolerations: []
  affinity: {}
  podAnnotations: {}
  podLabels: {}

  service:
    type: ClusterIP
    port: 3001
    annotations: {}
    # WHO MAY REACH IT, when the type is LoadBalancer. Empty means everybody, which is what a cloud
    # load balancer does by default and almost never what somebody wants for an internal tool. Narrow
    # it to the addresses your people come from. Not every cloud honours this on every load balancer
    # type, so treat it as one layer rather than the only one.
    loadBalancerSourceRanges: []

  # Probes hit the API's own health route.
  livenessProbe:
    initialDelaySeconds: 20
    periodSeconds: 20
    timeoutSeconds: 5
    failureThreshold: 6
  readinessProbe:
    initialDelaySeconds: 5
    periodSeconds: 10
    timeoutSeconds: 5
    failureThreshold: 3
  startupProbe:
    periodSeconds: 5
    failureThreshold: 60

serviceAccount:
  create: true
  name: ""
  # ONE MAP, THREE CLOUDS. IRSA on EKS, Workload Identity on GKE and on AKS are all annotations on a
  # ServiceAccount, so this covers every one of them and the chart needs no idea which it is on.
  #   eks.amazonaws.com/role-arn: arn:aws:iam::<account>:role/<role>
  #   iam.gke.io/gcp-service-account: <name>@<project>.iam.gserviceaccount.com
  #   azure.workload.identity/client-id: <client-id>
  annotations: {}
  automountServiceAccountToken: false

# The database migrations, run as a Job before the API starts. A pre-upgrade hook, so a rollout
# never puts a new replica in front of a schema it has not seen.
migrations:
  enabled: true
  backoffLimit: 3
  # How long to wait for the database to accept connections before giving up. A pre-install hook runs
  # before the chart's own resources, so on a first install with the bundled database this Job starts
  # before the database does.
  waitForDatabaseSeconds: 300
  # A ceiling on the whole Job, so a migration that hangs fails the release rather than holding it.
  activeDeadlineSeconds: 900
  # Kept on failure so somebody can read why. Helm deletes it before the next run.
  resources:
    requests:
      cpu: 100m
      memory: 256Mi
    limits:
      memory: 1Gi

# What OpenBot needs to run. Anything secret belongs in `secrets` below, never here.
config:
  # Where people reach this deployment. Sets the OAuth callback and the trusted origin.
  publicUrl: ""
  # Web Bot Auth: every request a Bot's browser makes is signed as coming from this deployment, and
  # the public key is published at `<publicUrl>/.well-known/http-message-signatures-directory`, so a
  # site behind Cloudflare that allows signed agents lets the Bot through instead of challenging it.
  # Off unless "on": signing announces the deployment's URL to every site a Bot visits. "on" needs an
  # https `publicUrl` (verifiers fetch the key from it) and earns nothing until the deployment is
  # registered with Cloudflare, a manual step described in the chart README. The key is derived from
  # `secrets.keyEncryptionKey` unless `secrets.webBotAuthKey` gives one.
  webBotAuth: ""
  # Administrators by email address, comma-separated. Required unless singleUser is on.
  initialAdminEmails: ""
  # Email domains admitted at sign-in, comma-separated. Empty admits everybody, which is what the
  # providers below already do on their own: the Entra tenant is `common` unless you set it, which
  # is any Microsoft account including personal ones, and Okta has no equivalent setting.
  #
  # A filter, not a boundary. It is checked against the address the provider returns, and OpenBot
  # does not require a verified one, so the server REFUSES this combined with an Entra tenant of
  # `common`: there the address is written by the tenant signing in. Set `auth.microsoft.tenantId`.
  #
  # Matched exactly, no wildcards: `example.com` admits neither `sub.example.com` nor
  # `evil-example.com`. Name every domain your staff use.
  allowedEmailDomains: ""
  # Every request is one fixed administrator. Local trials only; the deployment refuses to start
  # with no identity provider unless this says somebody meant it.
  singleUser: false

  # How people sign in. One of these, or `singleUser` above, and nothing else will do: the server
  # refuses to start rather than serve a deployment where every visitor is an administrator.
  #
  # Client secrets go under `secrets` below. Only the public halves belong here.
  auth:
    google:
      clientId: ""
    microsoft:
      clientId: ""
      # `common` is Microsoft's own default and admits personal accounts as well as work ones. A
      # company that means "our staff" puts its directory GUID here.
      tenantId: ""
    okta:
      clientId: ""
      issuer: ""
  tenantPackageDir: /app/examples/fintech

  # CopilotKit Intelligence, which OpenBot requires. All four values are needed together: the server
  # refuses to start on a partial set, deliberately, because a half-configured Intelligence is a
  # mistake somebody made rather than a deployment that meant to run without one.
  intelligence:
    apiUrl: ""
    gatewayWsUrl: ""
    # The two secret halves live under `secrets` below, never here.
  # Learning defaults on; collection and delivery require an existing, assigned container.
  # With nothing saved in Admin and no containerId below, the server assigns the project's openbot
  # container on its own once it exists. The runtime key cannot create it, so `setup` below gives the
  # chart a credential that can; without one, the server log and Admin → Automatic Learning say
  # exactly what to run (scripts/setup-learning.ts, from a computer that can sign in to Intelligence).
  # Optional initial defaults; saved Admin → Automatic Learning settings take precedence, including off.
  learning:
    containerId: ""
    revision: ""
    # false stops the automatic assignment (OPENBOT_LEARNING_AUTO_ASSIGN=false).
    autoAssign: true
    # Creating the container. Name either Secret and a Job runs on every install and upgrade that
    # creates it in the runtime key's project, proves it with that key, and exits; the server then
    # assigns it. Both Secrets are yours: create them before installing.
    setup:
      # A CopilotKit CLI login, for managed Intelligence. Sign in into an empty folder and store the
      # file it writes (a person's 30-day session, so keep the Secret as tight as that warrants):
      #   COPILOTKIT_CONFIG_DIR="$(mktemp -d)"; export COPILOTKIT_CONFIG_DIR
      #   npx --yes copilotkit@latest login
      #   kubectl create secret generic openbot-copilotkit-cli \
      #     --from-file=config.json="$COPILOTKIT_CONFIG_DIR/auth/config.json"
      # The Job reads it once. The server never holds it.
      cliLoginSecret:
        name: ""
        key: config.json
      # An Intelligence service token, which creates Learning containers on a CopilotKit local
      # evaluation install only. Requires projectId: the numeric ID of the runtime key's project.
      # Passed to the server too, so Admin → Automatic Learning can create the container again.
      serviceTokenSecret:
        name: ""
        key: token
      projectId: ""
  # Memory sources and background research, on by default for each person and Bot (OpenBot turns
  # them on when a person talks to a Bot, and never back on once the person turns one off or removes
  # it). false stops new defaults for the whole deployment; existing settings are left as they are.
  memory:
    sourceDefaults: true
    researchDefaults: true
  # How far one Bot may hand work to another.
  #
  # A Bot addressing another is a grant an administrator makes, and these are the ceilings on what
  # that grant can cost. Both are deliberately mean: a hop is a whole agent turn at the other end,
  # several Bots asked in one turn cost several full runs rather than a fraction each, and with
  # `computers.mode: sandbox` a hop to a Bot whose browser is asleep also pays a pod resume. A chatty
  # Bot fanning out to four others wakes four machines.
  #
  # `maxDepth: 0` switches the capability off entirely: no Bot is offered the tool and the delivery
  # loop does not run.
  handoff:
    maxDepth: 1
    maxPerRun: 3
  # Your own Bot, over AG-UI.
  #
  # OpenBot is a shell for somebody else's agent, so this is the seam that matters: point it at a
  # service you run and coworkers created here reach it. Left empty, this deployment has only the
  # Bots its tenant package declares as built-in, and a package entry whose endpoint resolves to
  # nothing is dropped rather than registered as a coworker nobody can talk to.
  #
  # The address must be reachable from the server pod, so a Service in this cluster is named as
  # `http://my-agent.my-namespace:8000/ag-ui`, not as localhost.
  managedAgent:
    url: ""
    # The token travels in `secrets.managedAgentToken`. Required whenever a url is set: the server
    # refuses to start with one and not the other, because an unauthenticated Bot endpoint is an
    # open door to whatever that Bot can reach.

  # Slack and Microsoft Teams, through the OpenTag pairing.
  #
  # `enabled` is the switch, rather than the secret's presence, because a secret held in
  # `secrets.existingSecret` or a store is not readable at template time. The shared secret travels in
  # `secrets.opentagSharedSecret`; the server refuses one shorter than 32 characters, and refuses a
  # `url` or icon template with no secret at all.
  opentag:
    enabled: false
    # OpenTag's base URL, for messages sent when no Slack turn is open. Without it those sends fail
    # visibly in the outbox and Slack triggers are refused. Must be http(s).
    url: ""
    # Optional https PNG URL with `{seed}` or `{agentId}`, used as the Bot's Slack icon.
    botIconUrlTemplate: ""

  # Text messages, through Twilio. The server takes all four Twilio settings or none, so `enabled`
  # needs the three below and `secrets.twilioAuthToken`.
  sms:
    enabled: false
    accountSid: ""
    verifyServiceSid: ""
    fromNumber: ""

  # Push notifications and sign-in from the native app, through Expo.
  #
  # Setting `projectId`, the app's EAS project UUID, switches both on; the server refuses anything
  # that is not a UUID. `secrets.expoAccessToken` is optional and sent to Expo's push service when set.
  push:
    projectId: ""

  # The public origin Twilio calls back on, when it is not `publicUrl`. Twilio signs each request over
  # the URL it was given, so this has to be the address Twilio was configured with. Must be http(s).
  deliveryPublicUrl: ""

  # SCIM provisioning at `<publicUrl>/api/auth/scim/v2`.
  #
  # `enabled` needs `secrets.scimBearerToken`, the token the directory sends. A second token in
  # `secrets.scimBearerTokenNext` is accepted beside it, so the directory can move to a new one before
  # the old one is removed.
  scim:
    enabled: false
    # The name of the directory connection. Empty means the server's default, `directory`.
    connectionId: ""

  # Inbound email triggers: an SES receipt rule delivering through SNS to
  # `<publicUrl>/api/events/email/sns`. Both are needed; with either missing the route is not mounted.
  inboundEmail:
    # The domain the receipt rule covers, such as `in.example.com`.
    domain: ""
    # Comma-separated ARNs of the SNS topics allowed to deliver mail.
    snsTopicArns: ""

  # Every audit row as an OTLP log record over HTTP, for a SIEM or an OpenTelemetry Collector.
  #
  # Setting either endpoint switches export on. Headers, which usually carry a collector's API key,
  # are secrets: `secrets.otelHeaders` and `secrets.otelLogsHeaders`, as `key=value` pairs separated
  # by commas. With `networkPolicy.enabled`, a collector inside the cluster has to be named in
  # `networkPolicy.extraEgress`.
  otel:
    # Collector base URL; the server appends `/v1/logs`.
    endpoint: ""
    # Where log records go, used exactly as written. Takes precedence over `endpoint`.
    logsEndpoint: ""
    # The `service.name` on every record. Empty means the server's default, `openbot`.
    serviceName: ""
    # Stops export while an endpoint is still set.
    paused: false
  logLevel: ""
  # Free-form additions, for anything this chart has no opinion about.
  extraEnv: []
  extraEnvFrom: []
  # Volumes, and where to mount them, on every pod that loads this deployment's configuration: the
  # server and the routines and computer-culler CronJobs, the same pods `extraEnv` reaches. The usual
  # reason is a tenant package of your own, from a ConfigMap, with `tenantPackageDir` pointed at its
  # mount; every one of those pods reads the package, so mounting it on the server alone is not enough.
  #
  #   extraVolumes:
  #     - name: tenant
  #       configMap: { name: my-tenant-package }
  #   extraVolumeMounts:
  #     - name: tenant
  #       mountPath: /tenant
  #       readOnly: true
  extraVolumes: []
  extraVolumeMounts: []

# How a Bot gets a computer.
#
#   shared    One browser for every Bot, run by this chart. Needs nothing installed in the cluster,
#             and is what a first install should use. Each person's Bots keep their own logins
#             and files, but a command one Bot runs can read another's files. For that reason a
#             person's own OpenBot browser does not run here, and nobody records in a Bot's browser:
#             the Browser page and the Bot's screen say so.
#   sandbox   A computer for each person, and for each Isolated Bot, as a `Sandbox` from
#             kubernetes-sigs/agent-sandbox, suspended when idle and resumed with its logins
#             intact. Needs that controller in the cluster. Each person's own OpenBot browser gets a
#             computer of its own the same way.
#   external  Neither. `url` points at a computer somebody else runs, which is shared like the
#             first, so it runs no person's browser and records in no Bot's browser either.
computers:
  mode: shared
  # Only for `mode: external`. The other modes derive the address from what they created.
  url: ""
  # Never a literal. See `secrets` below.
  existingTokenSecret: ""

  # gVisor or Kata, where the cluster has one. Unset means an ordinary pod, because the three clouds
  # do not agree: GKE has managed gVisor, AKS offers Kata and gVisor, and on EKS it is bring your own
  # node configuration. A chart that assumed a RuntimeClass would fail to install without one.
  runtimeClassName: ""

  # Who the browser and the Bot's shell run as.
  #
  # KUBERNETES ONLY, and that is the scope rather than the whole of #261. The chart runs the
  # all-in-one image, whose `Dockerfile` creates `pwuser`, chowns `/workspace`, `/profiles` and
  # `/app` to it, and drops to it through s6. A computer pod overrides the command to run the
  # browser process alone, so it never reaches s6 and ran as uid 0. The Compose and supervisor
  # paths run `agent-computer/Dockerfile`, which builds no such user and is still uid 0; that is
  # the rest of #261's residual and is not this.
  #
  # WHAT IT BUYS, honestly. It is not a containment boundary against a Bot's own shell: the image
  # grants `pwuser` passwordless sudo for apt-get/apt/dpkg, and those escalate to root by design
  # (`-o APT::Update::Pre-Invoke=`). gVisor and a computer per Bot remain the actual boundary. What
  # this does buy is real and separate: the org policies and admission rules that reject uid 0
  # outright, root-owned data stops accumulating in the volumes, and any bug yielding a constrained
  # primitive lands as 1001 rather than as root.
  #
  # It does NOT move the pod between Pod Security Standards. `runAsNonRoot` is a restricted control
  # rather than a baseline one, and restricted also wants `allowPrivilegeEscalation: false`,
  # `capabilities.drop: [ALL]` and a seccomp profile, none of which are set here. Baseline was
  # already met; restricted still is not.
  #
  # 1001, not 1000, because the base is `ubuntu:24.04` and its own `ubuntu` user already holds 1000.
  # Verified by creating the user the way the Dockerfile does:
  #   docker run --rm ubuntu:24.04 sh -c 'useradd -m pwuser; id pwuser'  ->  uid=1001(pwuser)
  #
  # `fsGroup` is what makes an existing volume usable: it is created root-owned and the kubelet
  # applies the group on mount. `OnRootMismatch` is not a detail. Unset means `Always`, which walks
  # every file on EVERY mount, and a real Chromium profile is tens of thousands of small ones: in
  # `mode: sandbox` that pass would run again on every resume from idle, which is the latency
  # agent-sandbox exists to avoid. `OnRootMismatch` runs it once, when the root still says root.
  #
  # A NOTE ON STORAGE. The kubelet applies fsGroup only where the volume plugin says it can.
  # The EBS, PD and Azure Disk CSI drivers do. `hostPath` does not, and that is what
  # rancher/local-path-provisioner hands out by default, which is the default StorageClass on k3s.
  # There the computer now refuses to start with a message saying so, rather than coming up healthy
  # with an empty profile.
  #
  # Set `computers.podSecurityContext: null` to go back to running as root.
  #
  # NOTHING ELSE IS SET HERE ON PURPOSE. A capability drop was proposed in #262 and declined,
  # because gVisor is the sandbox boundary this ships and `apt-get` in a Bot's shell needs CHOWN,
  # DAC_OVERRIDE, FOWNER, SETUID and SETGID. `allowPrivilegeEscalation: false` is the same question
  # wearing a different hat: it is `no_new_privs`, which turns off the setuid bit `sudo apt-get`
  # depends on. The supervisor path already makes that trade (`docker.ts` sets
  # `no-new-privileges:true`), and can, because the image it runs installs no sudo at all. Add
  # either here if your deployment wants it and your Bots never install packages.
  podSecurityContext:
    runAsNonRoot: true
    runAsUser: 1001
    runAsGroup: 1001
    fsGroup: 1001
    fsGroupChangePolicy: OnRootMismatch

  # How many browsers one computer holds at once, and how long an untouched one is kept. Empty means
  # the process default, which is a handful and thirty minutes.
  maxBrowsers: ""
  browserIdleMs: ""
  # At what share of the pod's memory limit the computer starts closing browsers nobody is using,
  # least recently used first, down to ten points under it. Measured as the kubelet measures it (the
  # working set), before each launch and once a minute: it stops idle browsers filling the pod one
  # launch at a time, and a page that grows between two checks can still run the pod out of memory.
  # Empty means 85; 0 switches it off.
  memoryHighPercent: ""
  # How long a Bot's background tab (one it left behind, such as the page a sign-in popup opened from)
  # is kept untouched before it is closed. The page the Bot is on is never closed. Empty means ten
  # minutes; 0 keeps them.
  tabIdleMs: ""

  # Which Chromium a Bot's computer runs. `headed` is full Chromium drawing to the pod's own X server
  # (Xvfb, started by the computer), behind the same streamed screen: it is what sites see from a
  # person's browser, and Cloudflare's bot check challenges it far less than headless Chromium. Costs
  # a little more memory and CPU than `headless`, which is still available.
  browserMode: headed

  # A residential or ISP proxy for every Bot's outbound traffic. OFF BY DEFAULT, and an operator's
  # choice to make knowingly: through one, a Bot's traffic leaves from an address a consumer ISP owns,
  # so a site sees what looks like a person at home rather than a datacenter. That is the point (a
  # datacenter address is the other thing bot checks key on) and also the thing to be comfortable
  # with. The credentialed URL (`http://user:[email protected]:8000`) is a secret:
  # `secrets.egressProxyUrl`, or a key in a Secret of your own. It reaches every computer as
  # `EGRESS_PROXY_DEFAULT`, behind the egress filter, so the network policy still decides what a Bot
  # may reach. With `networkPolicy.enabled`, also name the proxy in
  # `networkPolicy.computerExtraEgress`. One Bot's own proxy is still `EGRESS_PROXY_<BOT>` in
  # `extraEnv` below.
  egressProxy:
    enabled: false
    # Empty uses the chart's Secret (`secrets.egressProxyUrl`).
    existingSecret: ""
    existingSecretKey: egress-proxy-url

  persistence:
    # EMPTY MEANS THE CLUSTER'S DEFAULT CLASS. Naming `gp3` or `pd-balanced` is how a chart stops
    # installing on a bare-metal cluster. Note that the ordinary block volume on every cloud is
    # zonal, so a computer is pinned to the zone its profile was created in.
    storageClass: ""
    profilesSize: 10Gi
    workspaceSize: 10Gi
    # What happens to a Bot's logins when the release is deleted. `Retain` keeps them, which is the
    # safe default; `Delete` is for a trial you want to leave no trace of.
    whenDeleted: Retain

  # SIZED FOR A PERSON, NOT A BOT. A computer is one person's and runs a browser for each of their
  # Bots in use at once, up to `maxBrowsers` (8 when empty), closing each after `browserIdleMs`
  # untouched (30 minutes when empty). Chromium is roughly 200-500MB per browser (a little more
  # headed, plus a few MB for Xvfb) and up to 2GB with real pages open. Running out of memory takes
  # down every one of that person's browsers at once, so size the limit to `maxBrowsers` times what
  # one browser takes on your Bots' sites, plus headroom; on a small node, lower `maxBrowsers` (the
  # least recently used browser closes first) rather than the limit.
  resources:
    requests:
      cpu: 500m
      memory: 2Gi
    limits:
      memory: 8Gi

  nodeSelector: {}
  tolerations: []
  # Free-form additions, and where a Bot's outbound address is set. `EGRESS_PROXY_DEFAULT` covers
  # every Bot and `EGRESS_PROXY_<BOT>` names one, upper-cased with anything unusual replaced, so
  # `sales-bot` reads `EGRESS_PROXY_SALES_BOT`. Both reach the computer whichever mode it runs in.
  # With `networkPolicy.enabled` the proxy also has to be named in
  # `networkPolicy.computerExtraEgress`, or the computer cannot reach it.
  extraEnv: []

  # `mode: sandbox` only. Where the per-Bot computers are created and what may create them.
  sandbox:
    # Refuse to install when the cluster has no Sandbox CRD, rather than succeeding and failing at
    # the first browser action. Turn it off only where the CRD arrives after this chart does, such as
    # a GitOps run that applies both together.
    requireController: true
    namespace: ""
    # Pre-warmed sandboxes, so a Bot's first action after lunch does not wait for Chromium to boot.
    #
    # Not usable yet, and the chart refuses to render with it on. A Bot reaches a warm sandbox by
    # claiming it, and nothing in the server creates a SandboxClaim: `locate` posts a new Sandbox and
    # waits for it, pool or no pool. Left here, with the template and the RBAC beside it, because the
    # missing half is the claim rather than any of this.
    warmPool:
      enabled: false
      replicas: 2
    # Suspend a computer nobody has used for this long. The Sandbox CRD has an absolute expiry, which
    # is not the same question, so the culler below asks this one.
    idleAfter: 30m
    culler:
      # A ceiling on one sweep. `concurrencyPolicy: Forbid` means a sweep that hangs holds the lock
      # for ever and culling stops silently, which is the failure this feature exists to prevent.
      activeDeadlineSeconds: 600
      enabled: true
      schedule: "*/5 * * * *"

# Standing instructions a Bot runs on a schedule. The sweep offers due routines to the shared work
# queue and hands each firing to the API server, which runs the turn as the person who scheduled it.
routines:
  # Off by default, because it needs a secret. Without `secrets.workerSharedSecret` the API server
  # refuses every handoff, and a CronJob whose every run is a 401 is worse than no CronJob at all.
  enabled: false
  # Inside the 15-minute floor the tools enforce, so a firing waits at most one tick.
  schedule: "*/5 * * * *"

# Deleting attachments somebody staged and then never sent. `attachedAt` stays null until an
# attachment is actually sent, and the upload endpoint counts exactly those null rows against two
# separate caps: eight per composer session, which is the per-message limit the composer's own screen
# enforces, and 32 per PERSON across every channel and every session at once, which is the one that
# makes this sweep load-bearing.
#
# The second cap is why never running this is worse than growth. The per-session eight is counted
# over a bucket the client names in its own request, so a new tab is a new bucket and it bounds a
# client that plays along and nothing else. The per-person 32 is not: it is every unsent row that
# person holds anywhere, and the refusal they see on the 33rd file tells them anything still unsent
# is cleared within a day, which is a promise made on this sweep's behalf. With the sweep off, a
# changed mind is a permanent dead end naming files that are no longer on anybody's screen, and
# anybody who reaches 32 can attach nothing, in any channel, for good.
attachments:
  culler:
    # On by default, unlike `routines` above: this needs nothing but the database, which every
    # deployment already has, so there is no failure mode where enabling it does more harm than the
    # rows it was written to remove. Nothing but the database is meant literally — the script reads
    # `DATABASE_URL` and no other variable, which is why this CronJob carries no secret at all.
    enabled: true
    # Hourly, not the five-minute schedule the other two CronJobs use: nothing here is time-sensitive
    # the way a due routine or an idle browser is.
    schedule: "0 * * * *"
    # How long a staged attachment is kept before the sweep deletes it. Matches the script's own
    # fallback, so leaving this out and never running the CronJob behave alike.
    #
    # A fraction is a fraction of an hour: `0.5` is thirty minutes. Be sure that is what you want —
    # this deletes files a person picked in the composer and has not sent, and a window shorter than
    # somebody's train of thought deletes one out from under them while the tab is still open.
    olderThanHours: 24
    # A ceiling on one sweep, because `concurrencyPolicy: Forbid` turns a hung one into a permanent
    # stop. A deployment arriving with a large backlog does not need it raised: the sweep deletes in
    # bounded batches, each its own transaction, so a run stopped at the ceiling keeps what it
    # committed and the next one carries on from there. Raising it drains that backlog in fewer runs.
    activeDeadlineSeconds: 300

database:
  # Used when `postgresql.enabled` is false. A URL, or a secret holding one.
  #
  # PUT `?sslmode=require` ON IT. Every managed database refuses an unencrypted connection: RDS has
  # `rds.force_ssl` on by default, and Cloud SQL and Azure Database do the same. Without it the
  # migration fails with `no pg_hba.conf entry for host ... no encryption`, which names the host and
  # the user and not the actual problem.
  #
  #   postgres://user:password@host:5432/openbot?sslmode=require
  #
  # Keep it in a Secret rather than here: `url` is readable by anybody who can read the release.
  url: ""
  existingSecret: ""
  existingSecretKey: "database-url"

# The bundled database. Off by default in favour of a managed one.
# The bundled database.
#
# NOT PRODUCTION-GRADE, AND OFF FOR THAT REASON. A database on a pod is a database that goes away
# when the pod does: a rollout, a node drain or an evicted pod is a restart, and while the volume
# survives, nothing about this shape gives you backups, failover, point-in-time recovery or a
# connection that outlives the release. It exists so somebody can try OpenBot in one command.
#
# A REAL DEPLOYMENT POINTS `database` ABOVE AT A MANAGED DATABASE: RDS, Cloud SQL, Azure Database, or
# your own server. That is the same line the Intelligence chart draws, and for the same reason.
postgresql:
  enabled: false
  auth:
    # THE SUPERUSER, DELIBERATELY, AND ONLY FOR THIS BUNDLED DATABASE.
    #
    # The first migration runs `CREATE EXTENSION vector` and a later one drops it again, and only a
    # superuser can do either. An ordinary role fails the install at migration one with "permission
    # denied to create extension", which reads like a broken chart rather than a database privilege.
    #
    # This is the shape `docker-compose.yml` already ships, where the app user is the cluster
    # superuser, and it is safe for the same reason: this database exists for this release alone and
    # nothing else can reach it.
    #
    # A MANAGED DATABASE IS NOT THIS. On RDS, Cloud SQL or Azure there is no superuser to hand out,
    # so create the extension once as the administrative role and grant the migrating role ownership
    # of it. `CREATE EXTENSION IF NOT EXISTS` then passes for an ordinary user.
    username: postgres
    database: openbot
    # SET ONE, OR UPGRADES FAIL. The subchart generates a password on install and then refuses to
    # render on upgrade unless it is given the current one, which turns the second `helm upgrade`
    # into an error about credentials. A password you chose, or a Secret you made, makes the release
    # repeatable. The chart refuses to install without one rather than letting you find out later.
    password: ""
    existingSecret: ""
  image:
    # Bitnami moved its unsupported images to this frozen mirror. Nothing new lands here, so the tag
    # is named rather than inherited from the subchart: with it inherited, bumping the subchart
    # silently asks for an image the mirror does not have, and the chart still renders perfectly.
    repository: bitnamilegacy/postgresql
    tag: 17.6.0-debian-12-r4
  primary:
    # PINNED, BECAUSE THE SHIPPED DEFAULT ADMITS EVERYTHING.
    #
    # The subchart renders its NetworkPolicy whether or not this chart's own is enabled, and with
    # `allowExternal: true` its ingress rule carries no `from` at all: any pod in any namespace may
    # open 5432. That includes a Bot's computer, the one pod running a browser on pages a person
    # named and a shell on commands a model chose. Compose has kept the database off the Bot's
    # network since the beginning; this is the same boundary in the other deployment's words.
    #
    # With this off, the database admits pods labelled `<release>-postgresql-client`, which the API
    # server carries and nothing else does.
    networkPolicy:
      allowExternal: false
      allowExternalEgress: false
    persistence:
      enabled: true
      # EMPTY MEANS THE CLUSTER'S DEFAULT CLASS, and that is deliberate. Naming `gp3` or
      # `pd-balanced` here is exactly how a chart stops installing on somebody's bare-metal cluster.
      storageClass: ""
      size: 20Gi

# Secrets, without picking a vendor.
#
# A plain Kubernetes Secret is the default because that is what a self-hosted cluster has.
# `externalSecrets` turns the same fields into an ExternalSecret instead, so Secrets Manager, Secret
# Manager and Key Vault are a values block rather than three code paths.
secrets:
  # Point at a Secret you made yourself, and the chart creates none.
  existingSecret: ""
  # Created by the chart when `existingSecret` is empty. Pass with --set-string or a values file that
  # is not in version control; `KEY_ENCRYPTION_KEY` and the model credential are the two that matter
  # and neither should ever be a literal in a file anybody commits.
  keyEncryptionKey: ""
  betterAuthSecret: ""
  modelApiKey: ""
  computerToken: ""
  supervisorToken: ""
  # From the CopilotKit CLI: `npx --yes copilotkit@latest project select` prints the runtime key.
  # The chart refuses to install without it, because there is no mode where this runs with
  # Intelligence missing.
  intelligenceApiKey: ""
  # Optional. Managed Intelligence issues no licence token; set this only for a self-hosted
  # Intelligence that has one, and it is passed to the server as COPILOTKIT_LICENSE_TOKEN. From a
  # store, name `license-token` in `externalSecrets.data` instead; it is passed the same way. That
  # Intelligence needs the licence on its own deployment too, or it refuses memory.
  licenseToken: ""
  # Optional. One key for the whole deployment, for Composio, the broker holding people's accounts for
  # a few hundred apps (docs/plugins/composio.md). Passed to the server alone as COMPOSIO_API_KEY.
  # From a store, name `composio-api-key` in `externalSecrets.data` instead.
  composioApiKey: ""
  # Sent to `config.managedAgent.url` on every call. Required when that url is set.
  managedAgentToken: ""
  # Required when `routines.enabled`: what the CronJob presents to the API server to be recognised
  # as the worker rather than as an unauthenticated caller.
  workerSharedSecret: ""
  # The client secret for whichever provider is configured above.
  googleClientSecret: ""
  microsoftClientSecret: ""
  oktaClientSecret: ""
  # Required when `config.opentag.enabled`. At least 32 characters. Generate one with:
  # openssl rand -hex 32
  opentagSharedSecret: ""
  # Required when `config.sms.enabled`.
  twilioAuthToken: ""
  # Optional, with `config.push.projectId`.
  expoAccessToken: ""
  # Required when `config.scim.enabled`; the next one is optional, for rotation.
  scimBearerToken: ""
  scimBearerTokenNext: ""
  # Optional, with `config.otel`. Headers for the logs endpoint, and the general ones used when the
  # logs ones are unset.
  otelLogsHeaders: ""
  otelHeaders: ""
  # Optional, with `config.webBotAuth`. An Ed25519 private key as a JSON Web Key, to sign with instead
  # of the one derived from `keyEncryptionKey`. Read from key `web-bot-auth-key` of whichever Secret
  # this chart uses, when present.
  webBotAuthKey: ""
  # Required when `computers.egressProxy.enabled` and no `existingSecret` is named there.
  egressProxyUrl: ""

externalSecrets:
  enabled: false
  # Whatever your cluster's ClusterSecretStore or SecretStore is called. Backend-agnostic on purpose.
  secretStoreRef:
    name: ""
    kind: ClusterSecretStore
  refreshInterval: 1h
  # remoteRef keys, one per secret this chart reads.
  data: []

ingress:
  enabled: false
  # The controller differs on every cluster and always will, so this is a value with no default.
  className: ""
  annotations: {}
  hosts:
    - host: openbot.example.com
      paths:
        - path: /
          pathType: Prefix
  tls: []

# Gateway API, as an alternative rather than a replacement. Plenty of self-hosted clusters still run
# an Ingress controller, so both are here and neither is assumed.
httpRoute:
  enabled: false
  parentRefs: []
  hostnames: []

networkPolicy:
  enabled: false
  # Where the API may reach out to. A deployment with a managed database adds its CIDR here.
  #
  # It already reaches HTTP and HTTPS everywhere outside the cluster's private ranges, because that
  # is where Intelligence, sign-in and the Bots are. This is for anything on the private side.
  extraEgress: []
  extraIngress: []
  # `computers.mode: sandbox` only. The service range the Kubernetes API server answers on, so the
  # rule that lets the API ask for a Bot's computer can name it.
  #
  # REQUIRED once `enabled` is true and `computers.mode` is sandbox, and empty here because the range
  # is the cluster's rather than the release's, so there is nothing this chart could put in its place.
  # `kubectl get svc kubernetes -o jsonpath='{.spec.clusterIP}'` shows which one yours is on; on EKS
  # it is usually 172.20.0.0/16, on GKE and kubeadm 10.96.0.0/12.
  #
  # Empty USED to mean unscoped, and unscoped was not a looser version of this rule — it was the
  # absence of one. An egress rule with ports and no `to` matches every destination in Kubernetes, so
  # the default granted 443 and 6443 to all of `10/8`, `172.16/12`, `192.168/16` and `169.254/16`,
  # which are the four ranges the rule beside it exists to cut out. It is refused rather than skipped
  # because skipping it is an outage nobody is told about: on a cluster that enforces policy the API
  # server can no longer ask for a computer and every Bot action fails. A `helm upgrade` that stops
  # here has changed nothing in the cluster; set this and run it again.
  kubernetesApiCidr: ""
  # Where a Bot's computer may reach beyond the public internet. A deployment whose Bots must reach
  # an internal site adds it here, one address at a time, rather than reopening the private ranges.
  computerExtraEgress: []
  # Extra egress for the culler. Empty falls back to `extraEgress`, where an external database is
  # already named; set it to give the culler a narrower list.
  cullerExtraEgress: []
  # The same, for the routines sweep.
  routinesExtraEgress: []
  # The same, for the attachments culler.
  attachmentsCullerExtraEgress: []

podSecurityContext:
  runAsNonRoot: false
  fsGroup: null
securityContext: {}

# Applied to every pod this chart creates.
commonLabels: {}
commonAnnotations: {}