elan-agentkit-runtime 0.1.0__tar.gz

elan_agentkit_runtime-0.1.0/.gitignore

@@ -0,0 +1,45 @@
+__pycache__/
+*.py[cod]
+.venv/
+.env
+.env.docker
+.uvcache/
+dist/
+build/
+*.egg-info/
+node_modules/
+.next/
+# TypeScript incremental build cache: rewritten by every portal build, so
+# tracking it dirties the tree on each one and now on every CI run.
+*.tsbuildinfo
+.terraform/
+.terraform.lock.hcl
+tfplan
+*.tfstate*
+.pytest_cache/
+.ruff_cache/
+catalog.json
+.ref/
+
+.local/
+# Per environment (ADR-0179): one shared file meant building for a second
+# environment overwrote the first's recorded digests.
+.platform-digests.*
+
+# Terraform plan files. Build artefacts, and a plan can carry values read
+# from state — including ones marked sensitive. `tfplan` alone did not match
+# `np.tfplan`, which is how one came to be committed.
+*.tfplan
+
+# Per-developer Claude Code settings. `.claude/settings.json` is the shared,
+# checked-in one; this is the personal override beside it, and it routinely
+# holds machine-specific permission grants — a `kubectl exec` allowance for
+# somebody's own cluster has no business in a repo that is also the starter
+# template for new projects.
+.claude/settings.local.json
+
+# GENERATED AT BUILD from the prerendered documentation, by
+# ui/console/scripts/gen-llms.mjs. A build artifact like `.next` and the SDK's
+# `dist`: committing it would mean a second copy of every documentation page
+# in the history, going stale between builds.
+ui/console/public/llms-full.txt

elan_agentkit_runtime-0.1.0/Dockerfile

@@ -0,0 +1,74 @@
+# ONE image serves every agent and workflow; TARGET_SLUG selects which.
+# Build from the repo root:  docker build -f agent-pipeline/runtime/Dockerfile .
+#
+# Layer order matters: because definitions are code, a one-word prompt edit
+# rebuilds the image. Dependencies and the platform layer are cached, and only
+# agents/ + workflows/ invalidate at the very end, so that rebuild stays cheap.
+FROM python:3.12-slim-bookworm AS builder
+
+# Copy the uv binary in rather than depending on a uv+python tag combination.
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
+ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy
+WORKDIR /app
+
+# 1. Dependency manifests only -> this layer survives every source change.
+# THESE MEMBER MANIFESTS ARE INERT WITH TODAY'S uv, AND THAT WAS MEASURED
+# rather than assumed. `uv sync --frozen --no-install-workspace` resolves
+# entirely from `uv.lock`: on uv 0.11.26 the step below succeeds with only
+# `pyproject.toml` and `uv.lock` in the context and every line beneath this
+# comment deleted. What it CANNOT do without the real source is the second
+# sync, which installs the workspace — and that source arrives with
+# `COPY packages/` further down, so these lines are not what makes it work.
+#
+# THEY ARE KEPT, AND THE REASON IS READABILITY RATHER THAN RESOLUTION. The
+# list is how a reader sees which members this image's graph contains, so an
+# INCONSISTENT list is worse than a uniformly inert one: naming
+# agentkit-core and not the package beneath it reads as a statement that the
+# second is not in the graph. `tests/test_docker_cache_layers.py` keeps the
+# set closed under the workspace dependency relation for that reason, and
+# keeps it from growing — every file here is part of this layer's CACHE KEY,
+# so a manifest nothing needs makes an unrelated edit reinstall every
+# dependency.
+#
+# WORTH DELETING OUTRIGHT, as a change of its own. `uv:latest` is what the
+# build pulls, so the measurement above is of a moving target — which is an
+# argument for making the decision deliberately rather than by attrition.
+COPY pyproject.toml uv.lock ./
+COPY packages/elan-agentkit-contracts/pyproject.toml packages/elan-agentkit-contracts/
+COPY packages/agentkit-core/pyproject.toml packages/agentkit-core/
+COPY agent-pipeline/plugins/pyproject.toml agent-pipeline/plugins/
+COPY agent-pipeline/runtime/pyproject.toml agent-pipeline/runtime/
+# --package selects ONLY the runtime and its workspace dependencies. Without it
+# uv resolves the root aggregate package, which depends on every service and
+# would need ledger/rt/observability sources in this image.
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-install-workspace --no-dev --package elan-agentkit-runtime
+
+# 2. Platform source — changes only when the runtime or plugins change.
+COPY packages/ packages/
+COPY agent-pipeline/plugins/ agent-pipeline/plugins/
+COPY agent-pipeline/runtime/ agent-pipeline/runtime/
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev --package elan-agentkit-runtime
+
+# 3. Target definitions LAST — the layer that changes most often.
+COPY agent-pipeline/agents/ agent-pipeline/agents/
+COPY agent-pipeline/workflows/ agent-pipeline/workflows/
+
+
+FROM python:3.12-slim-bookworm AS runtime
+
+RUN useradd --create-home --uid 1000 app
+WORKDIR /app
+COPY --from=builder --chown=app:app /app /app
+
+ENV PATH="/app/.venv/bin:$PATH" \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    TARGETS_ROOT=/app/agent-pipeline \
+    PORT=8080
+
+USER app
+EXPOSE 8080
+CMD ["sh", "-c", "uvicorn agentkit_runtime.main:app --host 0.0.0.0 --port ${PORT}"]

elan_agentkit_runtime-0.1.0/Dockerfile.base

@@ -0,0 +1,149 @@
+# The image every TENANT image is built on top of: the platform runtime, and
+# nothing of this repo's own agents.
+#
+# WHY THIS IS A SEPARATE FILE FROM `Dockerfile`. That one builds the platform's
+# own fleet and copies `agent-pipeline/agents/` and `agent-pipeline/workflows/`
+# in at the last layer. A tenant image built on it would CONTAIN OUR EXAMPLES,
+# and `manifest_export` enumerates whatever is under the targets root — so the
+# tenant's own crosscheck would be handed `hotel-concierge` as an undeclared
+# target and their deploy would be refused for an agent they have never seen.
+# The fix is not to filter the export; it is not to ship them.
+#
+# THREE THINGS THE TENANT LAYER NEEDS THAT THE FLEET IMAGE DOES NOT HAVE, which
+# is the rest of the reason this file exists:
+#
+#   1. `uv` IN THE FINAL STAGE. `Dockerfile` copies it into the builder stage
+#      only, so `RUN uv sync` against that image fails with `uv: not found`.
+#      A tenant layer installs dependencies, so it needs the installer.
+#   2. A VENV IT MAY ADD TO. `UV_PROJECT_ENVIRONMENT` points at the same
+#      `/app/.venv` the platform runtime lives in, so a tenant's dependencies
+#      are resolved AGAINST ours rather than beside them — see Dockerfile.tenant
+#      for why that is the honest arrangement.
+#   3. WRITABLE OWNERSHIP for uid 1000, so the tenant layer installs as a user
+#      rather than needing root back.
+#
+# IT ALSO CARRIES `Dockerfile.tenant` AT /opt/elan/. That recipe is written
+# against THIS image's internals — the venv path, the user, uv being present —
+# so publishing the two separately means they can drift, and the drift surfaces
+# as a tenant's build failing on something they did not write. Shipping the
+# recipe inside the image it is pinned to makes `RUNTIME_BASE` one thing to
+# pin instead of two things to keep in step. The tenant build extracts it with
+# `docker cp`; see gitops/gcp/cloudbuild-tenant.yaml.
+
+FROM python:3.12-slim-bookworm AS builder
+
+# PINNED, unlike the fleet image's `uv:latest`. This image is a published
+# artifact other people's builds depend on, so "whatever uv was current the day
+# it built" is not a property it may have.
+COPY --from=ghcr.io/astral-sh/uv:0.9.7 /uv /uvx /bin/
+
+ENV UV_COMPILE_BYTECODE=1 UV_LINK_MODE=copy
+WORKDIR /app
+
+# THESE MEMBER MANIFESTS ARE INERT WITH TODAY'S uv, AND THAT WAS MEASURED
+# rather than assumed. `uv sync --frozen --no-install-workspace` resolves
+# entirely from `uv.lock`: on uv 0.11.26 the step below succeeds with only
+# `pyproject.toml` and `uv.lock` in the context and every line beneath this
+# comment deleted. What it CANNOT do without the real source is the second
+# sync, which installs the workspace — and that source arrives with
+# `COPY packages/` further down, so these lines are not what makes it work.
+#
+# THEY ARE KEPT, AND THE REASON IS READABILITY RATHER THAN RESOLUTION. The
+# list is how a reader sees which members this image's graph contains, so an
+# INCONSISTENT list is worse than a uniformly inert one: naming
+# agentkit-core and not the package beneath it reads as a statement that the
+# second is not in the graph. `tests/test_docker_cache_layers.py` keeps the
+# set closed under the workspace dependency relation for that reason, and
+# keeps it from growing — every file here is part of this layer's CACHE KEY,
+# so a manifest nothing needs makes an unrelated edit reinstall every
+# dependency.
+#
+# WORTH DELETING OUTRIGHT, as a change of its own. `uv:latest` is what the
+# build pulls, so the measurement above is of a moving target — which is an
+# argument for making the decision deliberately rather than by attrition.
+COPY pyproject.toml uv.lock ./
+COPY packages/elan-agentkit-contracts/pyproject.toml packages/elan-agentkit-contracts/
+COPY packages/agentkit-core/pyproject.toml packages/agentkit-core/
+COPY agent-pipeline/plugins/pyproject.toml agent-pipeline/plugins/
+COPY agent-pipeline/runtime/pyproject.toml agent-pipeline/runtime/
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-install-workspace --no-dev --package elan-agentkit-runtime
+
+COPY packages/ packages/
+COPY agent-pipeline/plugins/ agent-pipeline/plugins/
+COPY agent-pipeline/runtime/ agent-pipeline/runtime/
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev --package elan-agentkit-runtime
+
+# NO `COPY agent-pipeline/agents/` AND NO `COPY agent-pipeline/workflows/`.
+# That absence is the whole point of the file; see the header.
+
+
+FROM python:3.12-slim-bookworm AS runtime
+
+# DEBIAN SECURITY UPDATES, AND THE UPSTREAM TAG DOES NOT CARRY THEM.
+#
+# This is not belt-and-braces. Measured on 2026-09-27: `python:3.12-slim-
+# bookworm`, freshly pulled, ships `openssl 3.0.20-1~deb12u2` while Debian's
+# own security repository has offered `3.0.22-1~deb12u1` — the fix for
+# CVE-2026-75803 — for some time. The image tag is rebuilt on its own
+# schedule, so "pull the latest base" does NOT get the patch, and the first
+# tenant deploy after a CVE lands is refused by our own scan gate with nothing
+# the tenant can do about it. That is what happened.
+#
+# EVERY PACKAGE, NOT A LIST OF THE ONES WE KNOW ABOUT. A targeted
+# `--only-upgrade openssl libssl3` fixes today and needs editing the next time
+# a different library is the one with the CVE — and the way we would find out
+# is another tenant's deploy being refused. The scan gate is what makes this
+# safe to do broadly: an upgrade that broke something would fail the build
+# rather than ship.
+#
+# THIS DOES NOT MAKE THE IMAGE UNREPRODUCIBLE in any way it was not already.
+# `apt-get update` already pins nothing; what makes a platform image
+# reproducible here is that every consumer references it BY DIGEST, and the
+# digest changes when this layer does.
+RUN apt-get update \
+ && DEBIAN_FRONTEND=noninteractive apt-get upgrade -y --no-install-recommends \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
+
+COPY --from=ghcr.io/astral-sh/uv:0.9.7 /uv /uvx /bin/
+
+RUN useradd --create-home --uid 1000 app
+WORKDIR /app
+COPY --from=builder --chown=app:app /app /app
+
+# The recipe that builds a tenant image on top of this one. Read by the build,
+# never by the running pod.
+COPY --chown=root:root agent-pipeline/runtime/Dockerfile.tenant /opt/elan/Dockerfile.tenant
+
+ENV PATH="/app/.venv/bin:$PATH" \
+    # `VIRTUAL_ENV`, and NOT `UV_PROJECT_ENVIRONMENT`, which governs uv's
+    # PROJECT commands (`uv sync`, `uv run`) — and the tenant layer uses
+    # `uv pip`, which reads this one. With neither set, `uv pip install`
+    # discovers `.venv` relative to the working directory, so it happens to
+    # work from /app and silently creates a second environment from anywhere
+    # else. uvicorn would never look in that one.
+    VIRTUAL_ENV=/app/.venv \
+    UV_LINK_MODE=copy \
+    PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    # POINTED AT A DIRECTORY THAT IS EMPTY HERE, and populated by the tenant
+    # layer. Running this image directly discovers no targets, which is correct:
+    # it is a base, not a runnable agent.
+    TARGETS_ROOT=/app/targets \
+    PORT=8080
+
+# `/app` ITSELF, not only its contents. `COPY --from=builder --chown=app:app`
+# above sets ownership on what it copies IN, and leaves the directory it copies
+# into owned by root — so the tenant layer can write a file under /app and then
+# not be able to delete it, because unlinking needs write on the PARENT. That
+# surfaces as `rm: cannot remove: Permission denied` two files away from the
+# line that caused it.
+RUN chown app:app /app \
+    && mkdir -p /app/targets/agents /app/targets/workflows \
+    && chown -R app:app /app/targets
+
+USER app
+EXPOSE 8080
+CMD ["sh", "-c", "uvicorn agentkit_runtime.main:app --host 0.0.0.0 --port ${PORT}"]

elan_agentkit_runtime-0.1.0/Dockerfile.tenant

@@ -0,0 +1,91 @@
+# The image a TENANT'S repo becomes. Supplied by the platform, never by them.
+#
+# NO TENANT-SUPPLIED DOCKERFILE, and that removes a whole attack surface rather
+# than mitigating one. A Dockerfile is a program: it can `RUN` anything, add any
+# base image, and install from any registry — so accepting one would mean the
+# build sandbox's contents were chosen by the same person whose code we are
+# sandboxing. `elan.yaml` has no `dockerfile:` key for this reason.
+#
+# ONE IMAGE FOR THE WHOLE REPO, with TARGET_SLUG selecting which agent a pod
+# runs. The layer ordering below is what makes that cheap: the tenant's
+# dependencies resolve before any of their agent code is copied, so editing an
+# agent rebuilds one layer rather than reinstalling everything.
+#
+# THE COST, STATED PLAINLY because a tenant will meet it: every target in the
+# repo shares one dependency set. Two agents wanting incompatible versions of
+# one library is a BUILD failure rather than an isolated one, and every agent's
+# cold start pays for every dependency in the repo. The escape hatch is to split
+# into two projects — two repos, two images, two elan.yaml files.
+#
+# THIS FILE SHIPS INSIDE THE BASE IMAGE at /opt/elan/Dockerfile.tenant and the
+# build extracts it from there. It is written against that image's internals —
+# the venv at /app/.venv, uid 1000 owning it, uv on PATH — so the two travel
+# together and `RUNTIME_BASE` is one thing to pin. See Dockerfile.base.
+
+ARG RUNTIME_BASE
+FROM ${RUNTIME_BASE}
+
+# NOT `USER root`. The base already dropped to uid 1000 and gave it the venv, so
+# a tenant's dependencies install as an unprivileged user — which matters here
+# more than usual, because resolving a dependency runs ARBITRARY CODE: a
+# source-only package's build backend is tenant-chosen Python executing at
+# install time.
+WORKDIR /app
+
+# Their DEPENDENCIES, before their code, so an edit to an agent does not
+# reinstall them.
+#
+# INTO A DIRECTORY OF ITS OWN, AND STILL CALLED `pyproject.toml`, for two
+# separate reasons that both look like fussiness until they bite:
+#
+#   /app ALREADY HAS A pyproject.toml — the platform's. Copying the tenant's
+#   over it would replace the description of the environment their code runs
+#   in with a description of their own package.
+#
+#   uv DISPATCHES ON THE FILENAME. `uv pip install -r tenant-pyproject.toml`
+#   does not read a renamed pyproject; it refuses with "is not a valid PEP 751
+#   filename: expected TOML file to start with `pylock.`", which names a
+#   standard nobody here is using and sends you looking for a lockfile.
+#   AND IT IS OPTIONAL. The bracket glob is Docker's way of saying "copy this
+#   if it exists" — a plain COPY of a missing file fails the build with
+#   `"/pyproject.toml" not found`, from a layer, naming neither elan.yaml nor
+#   targetsRoot. The first canary deploy died exactly there.
+#
+#   A repo whose agents need nothing beyond the platform runtime has nothing to
+#   declare, and should not have to write an empty file to say so. That is a
+#   real tenant case and not an accommodation for the canary — though the
+#   canary is what found it.
+COPY --chown=app:app pyproject.tom[l] /app/.tenant/
+
+# `uv pip install`, NEVER `uv sync`. Sync makes the environment MATCH the
+# lockfile, and the tenant's lockfile does not contain the platform runtime —
+# so a sync would uninstall the very thing this image exists to provide, and
+# the pod would fail on `uvicorn: not found` long after the build went green.
+# Installing adds to what is already here.
+#
+# `uv pip check` is what makes the header's promise true rather than
+# aspirational. Without it a tenant pinning an older pydantic simply overwrites
+# ours, the build succeeds, and agentkit_core raises on import inside a pod at
+# 3am. With it, incompatible pins are a BUILD failure that names both sides.
+# THE INSTALL IS SKIPPED WHEN THERE IS NOTHING TO INSTALL, and `uv pip check`
+# still runs: an image with no tenant dependencies should still be verified
+# consistent, because the base itself can regress.
+RUN --mount=type=cache,target=/home/app/.cache/uv,uid=1000,gid=1000 \
+    if [ -f /app/.tenant/pyproject.toml ]; then \
+      uv pip install --requirement /app/.tenant/pyproject.toml; \
+    else \
+      echo "no pyproject.toml in the targets root — nothing to install"; \
+    fi \
+    && uv pip check \
+    && rm -rf /app/.tenant
+
+# Their targets, LAST, so this is the only layer an ordinary edit invalidates.
+# TARGETS_ROOT is already /app/targets in the base; these two directories are
+# exactly what `agentkit_runtime.registry.discover` scans.
+#
+# BOTH ARE GUARANTEED TO EXIST by the clone step, which creates them empty if
+# the repo has only one kind. A `COPY` of a missing directory is a build
+# failure, and "you have no workflows/ directory" is not a thing to fail a
+# tenant's deploy over.
+COPY --chown=app:app agents/ /app/targets/agents/
+COPY --chown=app:app workflows/ /app/targets/workflows/

elan_agentkit_runtime-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

elan_agentkit_runtime-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.5
+Name: elan-agentkit-runtime
+Version: 0.1.0
+Summary: The single container that runs any agent or workflow, selected by TARGET_SLUG
+Project-URL: Homepage, https://openelan.ai
+Project-URL: Documentation, https://openelan.ai/app/docs
+Author-email: Elan <support@openelan.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: adk,agents,llm,runtime
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: asyncpg>=0.30
+Requires-Dist: elan-agentkit-core
+Requires-Dist: elan-agentkit-plugins
+Requires-Dist: fastapi>=0.115
+Requires-Dist: google-adk<3,>=2.8.0
+Requires-Dist: google-auth>=2.35
+Requires-Dist: google-cloud-pubsub>=2.23
+Requires-Dist: google-cloud-storage>=2.18
+Requires-Dist: greenlet>=3.1
+Requires-Dist: mcp<2,>=1.2
+Requires-Dist: pydantic-settings>=2.6
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: uvicorn[standard]>=0.32
+Description-Content-Type: text/markdown
+
+# elan-agentkit-runtime
+
+The container runtime that runs any Elan agent or workflow, selected by
+`TARGET_SLUG`. It builds the ADK app, wires the plugins, and serves the
+invocation and resume paths.
+
+**This is a dependency, not a product.** `elan env` installs it into your
+project's virtual environment so `elan validate` and `elan adk` can read your
+manifests and run your agents locally. You are not expected to import it
+directly.
+
+Start at <https://openelan.ai/app/docs>.
+
+## Licence
+
+Apache-2.0. See `LICENSE`.

elan_agentkit_runtime-0.1.0/README.md

@@ -0,0 +1,16 @@
+# elan-agentkit-runtime
+
+The container runtime that runs any Elan agent or workflow, selected by
+`TARGET_SLUG`. It builds the ADK app, wires the plugins, and serves the
+invocation and resume paths.
+
+**This is a dependency, not a product.** `elan env` installs it into your
+project's virtual environment so `elan validate` and `elan adk` can read your
+manifests and run your agents locally. You are not expected to import it
+directly.
+
+Start at <https://openelan.ai/app/docs>.
+
+## Licence
+
+Apache-2.0. See `LICENSE`.