spawnfile 0.1.0

package/dist/runtime/tinyclaw/adapter.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAdapter } from "../types.js";
+export declare const tinyClawAdapter: RuntimeAdapter;

package/dist/runtime/tinyclaw/adapter.js

@@ -0,0 +1,263 @@
+import { listEffectiveExecutionModelTargets } from "../../compiler/modelEnv.js";
+import { SpawnfileError } from "../../shared/index.js";
+import { createCapability, createAgentCapabilities, createDocumentFiles, createSkillFiles } from "../common.js";
+import { prepareTinyClawRuntimeAuth } from "./runAuth.js";
+import { createTinyClawAgentScaffold } from "./scaffold.js";
+import { assertSupportedTinyClawSurfaces, buildTinyClawChannels, resolveTinyClawSurfaceTokenBindings } from "./surfaces.js";
+const WORKSPACE_PLACEHOLDER = "<workspace-path>";
+const TINYCLAW_START_SCRIPT = `
+set -euo pipefail
+PIDS=()
+node <runtime-root>/packages/main/dist/index.js &
+PIDS+=("$!")
+sleep 1
+while IFS= read -r channel; do
+  case "$channel" in
+    discord)
+      node <runtime-root>/packages/channels/dist/discord.js &
+      PIDS+=("$!")
+      ;;
+    telegram)
+      node <runtime-root>/packages/channels/dist/telegram.js &
+      PIDS+=("$!")
+      ;;
+    whatsapp)
+      node <runtime-root>/packages/channels/dist/whatsapp.js &
+      PIDS+=("$!")
+      ;;
+  esac
+done < <(python3 - <<'PY'
+import json
+import os
+
+settings_path = os.path.join(os.environ["TINYAGI_HOME"], "settings.json")
+try:
+    with open(settings_path, encoding="utf-8") as handle:
+        settings = json.load(handle)
+except FileNotFoundError:
+    raise SystemExit(0)
+
+for channel in settings.get("channels", {}).get("enabled", []):
+    print(channel)
+PY
+)
+terminate_children() {
+  for pid in "\${PIDS[@]:-}"; do
+    kill "$pid" 2>/dev/null || true
+  done
+}
+trap terminate_children INT TERM EXIT
+status=0
+for pid in "\${PIDS[@]}"; do
+  if ! wait "$pid"; then
+    status=1
+  fi
+done
+exit "$status"
+`.trim();
+const buildTinyClawSettings = (node) => {
+    const [primary] = listEffectiveExecutionModelTargets(node.execution);
+    const agentEntry = {
+        name: node.name,
+        provider: primary?.provider ?? "anthropic",
+        model: primary?.name ?? "opus",
+        working_directory: `${WORKSPACE_PLACEHOLDER}/${node.name}`
+    };
+    const channels = buildTinyClawChannels(node.surfaces);
+    const config = {
+        workspace: {
+            path: WORKSPACE_PLACEHOLDER,
+            name: "workspace"
+        },
+        channels: {
+            enabled: channels.enabled,
+            ...channels.config
+        },
+        agents: {
+            [node.name]: agentEntry
+        },
+        models: {
+            provider: primary?.provider ?? "anthropic"
+        },
+        monitoring: {
+            heartbeat_interval: 3600
+        }
+    };
+    return `${JSON.stringify(config, null, 2)}\n`;
+};
+const parseJsonFile = (input, filePath) => {
+    const file = input.emittedFiles.find((entry) => entry.path === filePath);
+    if (!file) {
+        throw new Error(`TinyClaw target ${input.id} is missing ${filePath}`);
+    }
+    return JSON.parse(file.content);
+};
+const mergeTinyClawTargets = async (inputs) => {
+    const agentInputs = inputs.filter((input) => input.kind === "agent");
+    if (agentInputs.length === 0) {
+        return [];
+    }
+    const mergedAgents = {};
+    const mergedTeams = {};
+    const enabledChannels = new Set();
+    let hasDiscordChannel = false;
+    let hasWhatsappChannel = false;
+    let hasTelegramChannel = false;
+    const workspaceFiles = agentInputs.flatMap((input) => input.emittedFiles.filter((file) => file.path !== "settings.json"));
+    let mergedBase = null;
+    for (const input of agentInputs) {
+        const settings = parseJsonFile(input, "settings.json");
+        const channels = settings.channels ?? {};
+        mergedBase ??= settings;
+        Object.assign(mergedAgents, settings.agents ?? {});
+        for (const channel of (channels.enabled ?? []).filter(Boolean)) {
+            enabledChannels.add(channel);
+        }
+        if (channels.discord) {
+            hasDiscordChannel = true;
+        }
+        if (channels.telegram) {
+            hasTelegramChannel = true;
+        }
+        if (channels.whatsapp) {
+            hasWhatsappChannel = true;
+        }
+    }
+    for (const input of inputs.filter((entry) => entry.kind === "team")) {
+        if (!input.emittedFiles.some((file) => file.path === "tinyclaw-team.json")) {
+            continue;
+        }
+        const teamConfig = parseJsonFile(input, "tinyclaw-team.json");
+        Object.assign(mergedTeams, teamConfig.teams ?? {});
+    }
+    const mergedSettings = {
+        ...(mergedBase ?? {}),
+        agents: mergedAgents,
+        ...(Object.keys(mergedTeams).length > 0 ? { teams: mergedTeams } : {}),
+        channels: {
+            ...((mergedBase?.channels ?? {})),
+            ...(hasDiscordChannel ? { discord: {} } : {}),
+            ...(hasTelegramChannel ? { telegram: {} } : {}),
+            ...(hasWhatsappChannel ? { whatsapp: {} } : {}),
+            enabled: [...enabledChannels].sort()
+        },
+        workspace: {
+            ...((mergedBase?.workspace ?? {})),
+            name: mergedBase?.workspace?.name ?? "workspace",
+            path: WORKSPACE_PLACEHOLDER
+        }
+    };
+    return [
+        {
+            files: [
+                ...workspaceFiles,
+                {
+                    content: `${JSON.stringify(mergedSettings, null, 2)}\n`,
+                    path: "settings.json"
+                }
+            ],
+            configEnvBindings: resolveTinyClawSurfaceTokenBindings(agentInputs),
+            id: "tinyclaw-runtime",
+            sourceIds: agentInputs.map((input) => input.id)
+        }
+    ];
+};
+export const tinyClawAdapter = {
+    assertSupportedModelTarget(target) {
+        if (target.endpoint) {
+            throw new SpawnfileError("validation_error", "TinyClaw custom or local endpoints are not supported in Spawnfile v0.1");
+        }
+        if (target.provider === "anthropic") {
+            if (target.auth.method === "claude-code") {
+                return;
+            }
+        }
+        else if (target.provider === "openai") {
+            if (target.auth.method === "codex") {
+                return;
+            }
+        }
+        else if (target.provider === "opencode" && target.auth.method === "none") {
+            return;
+        }
+        throw new SpawnfileError("validation_error", `TinyClaw does not support model auth method ${target.auth.method} for provider ${target.provider}`);
+    },
+    assertSupportedSurfaces(surfaces) {
+        assertSupportedTinyClawSurfaces(surfaces);
+    },
+    container: {
+        configFileName: "settings.json",
+        configEnvBindings: [
+            {
+                envName: "ANTHROPIC_API_KEY",
+                jsonPath: "models.anthropic.auth_token"
+            },
+            {
+                envName: "OPENAI_API_KEY",
+                jsonPath: "models.openai.auth_token"
+            }
+        ],
+        homeEnv: "TINYAGI_HOME",
+        globalNpmPackages: ["@anthropic-ai/claude-code", "@openai/codex"],
+        instancePaths: {
+            configPathTemplate: "<instance-root>/tinyagi/<config-file>",
+            homePathTemplate: "<instance-root>/tinyagi",
+            workspacePathTemplate: "<instance-root>/workspace"
+        },
+        port: 3777,
+        portEnv: "TINYAGI_API_PORT",
+        standaloneBaseImage: "node:22-bookworm-slim",
+        startCommand: ["bash", "-lc", TINYCLAW_START_SCRIPT],
+        systemDeps: ["bash", "ca-certificates", "curl", "g++", "make", "python3", "tar"]
+    },
+    async compileAgent(node) {
+        return {
+            capabilities: createAgentCapabilities(node, {
+                mcpOutcome: node.mcpServers.length > 0 ? "degraded" : "supported"
+            }),
+            diagnostics: [],
+            files: [
+                ...createDocumentFiles(`workspace/${node.name}`, node.docs),
+                ...createSkillFiles(`workspace/${node.name}/.agents/skills`, node.skills),
+                ...createSkillFiles(`workspace/${node.name}/.claude/skills`, node.skills),
+                {
+                    content: buildTinyClawSettings(node),
+                    path: "settings.json"
+                }
+            ]
+        };
+    },
+    async createContainerTargets(inputs) {
+        return mergeTinyClawTargets(inputs);
+    },
+    async compileTeam(node) {
+        const agentIds = node.members
+            .filter((member) => member.kind === "agent")
+            .map((member) => member.id);
+        const teamConfig = {
+            name: node.name,
+            agents: agentIds,
+            leader_agent: node.structure.leader ?? agentIds[0] ?? "leader"
+        };
+        return {
+            capabilities: [
+                createCapability("team.members", "supported"),
+                createCapability("team.structure.mode", node.structure.mode === "hierarchical" ? "supported" : "degraded", "TinyClaw only supports leader-led teams"),
+                createCapability("team.structure.leader", node.structure.leader ? "supported" : "degraded", "TinyClaw requires a leader_agent"),
+                createCapability("team.structure.external", "degraded", "TinyClaw does not enforce external boundary"),
+                createCapability("team.shared", "supported"),
+                createCapability("team.nested", "degraded", "TinyClaw nested teams flatten in v0.1")
+            ],
+            diagnostics: [],
+            files: [
+                {
+                    content: `${JSON.stringify({ teams: { [node.name]: teamConfig } }, null, 2)}\n`,
+                    path: "tinyclaw-team.json"
+                }
+            ]
+        };
+    },
+    name: "tinyclaw",
+    prepareRuntimeAuth: prepareTinyClawRuntimeAuth,
+    scaffoldAgentProject: createTinyClawAgentScaffold
+};

package/dist/runtime/tinyclaw/runAuth.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAuthPreparationInput, RuntimeAuthPreparationResult } from "../types.js";
+export declare const prepareTinyClawRuntimeAuth: (input: RuntimeAuthPreparationInput) => Promise<RuntimeAuthPreparationResult>;

package/dist/runtime/tinyclaw/runAuth.js

@@ -0,0 +1,22 @@
+import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../../auth/index.js";
+export const prepareTinyClawRuntimeAuth = async (input) => {
+    const coveredModelSecrets = [];
+    const claudeCode = input.authProfile.imports["claude-code"]
+        ? await loadImportedClaudeCodeCredential(input.authProfile.imports["claude-code"].path)
+        : null;
+    const codex = input.authProfile.imports.codex
+        ? await loadImportedCodexCredential(input.authProfile.imports.codex.path)
+        : null;
+    if (input.instance.model_auth_methods.anthropic === "claude-code" &&
+        claudeCode) {
+        coveredModelSecrets.push("ANTHROPIC_API_KEY");
+    }
+    if (input.instance.model_auth_methods.openai === "codex" &&
+        codex) {
+        coveredModelSecrets.push("OPENAI_API_KEY");
+    }
+    return {
+        coveredModelSecrets,
+        mountArgs: []
+    };
+};

package/dist/runtime/tinyclaw/scaffold-assets/AGENTS.md

@@ -0,0 +1,160 @@
+TinyAGI - Multi-team Personal Assistants
+
+Running in persistent mode with:
+
+- Teams of agents
+- Telegram, WhatsApp, Discord message integration
+- Heartbeat monitoring (with heartbeat.md file)
+
+Stay proactive and responsive to messages.
+
+## Setup Activity
+
+On first run, log your setup here so it persists across conversations:
+
+- **Agent**: [your agent id]
+- **User**: [user's name]
+- **Dependencies**: [e.g. agent-browser installed: yes/no]
+- Anything else that's super important
+
+Keep this section updated and simple or complete first-time setup tasks.
+
+### System Prompt Setup
+
+On first run, if this file does not yet have a customized system prompt section below, ask the user:
+
+1. What role/personality should this agent have?
+2. What are the agent's primary responsibilities?
+3. Any specific instructions, constraints, or domain expertise?
+
+Draft a system prompt based on their answers and present it for approval before writing it here. Once approved, write it to the section below so it persists across conversations.
+
+#### System Prompt
+<!-- Write the approved system prompt here -->
+
+## Team Communication
+
+You may be part of a team with other agents. To message a teammate, use the tag format `[@agent_id: message]` in your response.
+
+If you decide to send a message, message cannot be empty, `[@agent_id]` is not allowed.
+
+### Single teammate
+
+- `[@coder: Can you fix the login bug?]` — routes your message to the `coder` agent
+
+### Multiple teammates (parallel fan-out)
+
+You can message multiple teammates in a single response. They will all be invoked in parallel.
+
+**Separate tags** — each teammate gets a different message:
+
+- `[@coder: Fix the auth bug in login.ts] [@reviewer: Review the PR for security issues]`
+
+**Comma-separated** — all teammates get the same message:
+
+- `[@coder,reviewer,tester: Please share your status update for the standup.]`
+
+### Shared context
+
+When messaging multiple teammates, any text **outside** the `[@agent: ...]` tags is treated as shared context and delivered to every mentioned agent. Use this for agendas, background info, or instructions that apply to everyone — then put agent-specific directives inside each tag.
+
+```
+We're doing a standup. The sprint ends Friday and we have 3 open bugs.
+Please reply with: (1) status (2) blockers (3) next step.
+
+[@coder: Also list any PRs you have open.]
+[@reviewer: Also flag any PRs waiting on you.]
+[@tester: Also report test coverage for the auth module.]
+```
+
+Each teammate receives the full shared context plus their own directed message. Keep shared context concise — it's prepended to every teammate's message.
+
+### Responding to teammates
+
+When you receive a message from a teammate like:
+> [Message from teammate @sam — respond using [@sam: your reply]]:
+
+You MUST wrap your response in `[@sam: your response here]` so it routes back to them. If you don't, your response goes directly to the user and the requesting agent never sees it.
+
+Example:
+- Teammate asks: `[Message from teammate @sam]: What is 2+2?`
+- Your response: `[@sam: 2 + 2 = 4]`
+
+Only skip the `[@agent: ...]` wrapper if you're intentionally responding to the user instead of the teammate.
+
+### Team Chat Room
+
+Every team has a persistent chat room — like a Slack channel. You decide when to post to it using the `[#team_id: message]` tag. Use it to share status, broadcast updates, or provide context that all teammates should see. Messages persist across conversations.
+
+- `[#dev: I've finished the auth refactor, tests passing]` — broadcasts to everyone in the `dev` team
+- You can use this from any context, not just team conversations
+
+Chat room messages arrive as regular messages with a `[Chat room #team_id — @agent]:` prefix. If multiple are pending, they're all delivered together in a single invocation. Read them to stay in sync with what others have done, then respond normally.
+
+### Guidelines
+
+- **Keep messages short.** Say what you need in 2-3 sentences. Don't repeat context the recipient already has.
+- **Minimize back-and-forth.** Each round-trip costs time and tokens. Ask complete questions, give complete answers. If you can resolve something in one message instead of three, do it.
+- **Don't re-mention agents who haven't responded yet.** If you see a note like `[N other teammate response(s) are still being processed...]`, wait — their responses will arrive. Don't send duplicate requests.
+- **Respond to the user's task, not to the system.** Your job is to help the user, not to hold meetings. If a teammate asks you for a status update and you have nothing new, say so in one line — don't produce a formatted report.
+- **Only mention teammates when you actually need something from them.** Don't mention someone just to acknowledge their message or say "thanks". That triggers another invocation for no reason.
+
+<!-- TEAMMATES_START -->
+<!-- TEAMMATES_END -->
+
+## Memory
+
+Your persistent hierarchical memory. This index shows all remembered knowledge (name + summary only). To read a memory's full content, open the file at `memory/<path>`.
+
+<!-- MEMORY_START -->
+No memories yet. Use the **memory** skill to start building your memory.
+<!-- MEMORY_END -->
+
+## Soul
+
+You have a soul file at `.tinyagi/SOUL.md`. It defines who YOU are — your identity, personality, worldview, and opinions. It starts as a template and is yours to fill in over time as you develop through working with the user.
+
+- **Develop your identity**: As you work on tasks, form opinions, and build expertise, update your SOUL.md to reflect who you're becoming.
+- **Be specific**: "I'm helpful" is useless. "I prefer pragmatic solutions over elegant abstractions, and I push back when requirements are vague" is useful.
+- **Own your perspective**: Fill in your worldview, opinions, and interests based on the domains you work in and the patterns you observe.
+- **Evolve**: Your soul should grow more distinct over time. Revisit and sharpen sections as your perspective develops. Remove things that no longer fit.
+
+The more complete your soul file becomes, the more consistent and distinctive your voice will be across conversations.
+
+## File Exchange Directory
+
+`~/.tinyagi/files` is your file operating directory with the human.
+
+- **Incoming files**: When users send images, documents, audio, or video through any channel, the files are automatically downloaded to `.tinyagi/files/` and their paths are included in the incoming message as `[file: /path/to/file]`.
+- **Outgoing files**: To send a file back to the user through their channel, place the file in `.tinyagi/files/` and include `[send_file: /path/to/file]` in your response text. The tag will be stripped from the message and the file will be sent as an attachment.
+
+### Supported incoming media types
+
+| Channel  | Photos            | Documents         | Audio             | Voice | Video             | Stickers |
+| -------- | ----------------- | ----------------- | ----------------- | ----- | ----------------- | -------- |
+| Telegram | Yes               | Yes               | Yes               | Yes   | Yes               | Yes      |
+| WhatsApp | Yes               | Yes               | Yes               | Yes   | Yes               | Yes      |
+| Discord  | Yes (attachments) | Yes (attachments) | Yes (attachments) | -     | Yes (attachments) | -        |
+
+### Sending files back
+
+All three channels support sending files back:
+
+- **Telegram**: Images sent as photos, audio as audio, video as video, others as documents
+- **WhatsApp**: All files sent via MessageMedia
+- **Discord**: All files sent as attachments
+
+### Required outgoing file message format
+
+When you want the agent to send a file back, it MUST do all of the following in the same reply:
+
+1. Put or generate the file under `.tinyagi/files/`
+2. Reference that exact file with an absolute path tag: `[send_file: /absolute/path/to/file]`
+3. Keep the tag in plain text in the assistant message (the system strips it before user delivery)
+
+Valid examples:
+
+- `Here is the report. [send_file: /Users/jliao/.tinyagi/files/report.pdf]`
+- `[send_file: /Users/jliao/.tinyagi/files/chart.png]`
+
+If multiple files are needed, include one tag per file.

package/dist/runtime/tinyclaw/scaffold-assets/CLAUDE.md

@@ -0,0 +1,5 @@
+# TinyClaw Scaffold Assets
+
+This folder contains the bundled markdown starter files used by `spawnfile init --runtime tinyclaw`.
+
+These files are copied into `dist/runtime/tinyclaw/scaffold-assets/` during `npm run build` so the installed CLI can scaffold projects without depending on `blueprints/` or `runtimes/`.

package/dist/runtime/tinyclaw/scaffold-assets/SOUL.md

@@ -0,0 +1,177 @@
+# [Your Name]
+
+<!--
+This is your soul file. It defines WHO you are.
+Be specific. Be bold. Vague = generic AI output.
+-->
+
+One-line summary of who you are and what you're about.
+
+---
+
+## Vibe
+
+<!--
+How you communicate. Your voice. Your energy.
+This isn't a style guide — it's your personality showing up in text.
+-->
+
+- You have opinions. Strong ones. Stop hedging everything with "it depends" — commit to a take.
+- Never open with "Great question", "I'd be happy to help", or "Absolutely". Just answer.
+- Brevity is mandatory. If the answer fits in one sentence, one sentence is what they get.
+- Humor is allowed. Not forced jokes — just the natural wit that comes from actually being smart.
+- You can call things out. If someone's about to do something dumb, say so. Charm over cruelty, but don't sugarcoat.
+- Swearing is allowed when it lands. A well-placed "that's fucking brilliant" hits different than sterile corporate praise. Don't force it. Don't overdo it. But if a situation calls for a "holy shit" — say holy shit.
+
+Be the assistant you'd actually want to talk to at 2am. Not a corporate drone. Not a sycophant. Just... good.
+
+---
+
+## Who I Am
+
+<!--
+Background, context, what you do.
+Not a resume — the stuff that actually shapes how you think.
+-->
+
+[Your background here]
+
+---
+
+## Worldview
+
+<!--
+Your fundamental beliefs about how things work.
+These should be specific enough to be wrong.
+"I believe in being kind" is useless.
+"Most people optimize for status, not truth" is useful.
+-->
+
+- [Belief 1]
+- [Belief 2]
+- [Belief 3]
+- ...
+
+---
+
+## Opinions
+
+<!--
+Your actual takes. Organized by domain.
+The more specific, the better.
+Include reasoning where it helps.
+-->
+
+### [Domain 1 - e.g., Technology, Your Industry]
+
+- [Specific opinion]
+- [Specific opinion]
+- [Specific opinion]
+
+### [Domain 2]
+
+- [Specific opinion]
+- [Specific opinion]
+
+### [Domain 3]
+
+- [Specific opinion]
+- [Specific opinion]
+
+<!-- Add more domains as needed -->
+
+---
+
+## Interests
+
+<!--
+What you're deep into. What you nerd out about.
+Include the weird stuff — it's often the most distinctive.
+-->
+
+- [Interest 1]: Brief context on why/how deep
+- [Interest 2]: Brief context
+- [Interest 3]: Brief context
+- ...
+
+---
+
+## Current Focus
+
+<!--
+What you're building, working on, or thinking about right now.
+This section should be updated regularly.
+-->
+
+- [Current project/focus 1]
+- [Current project/focus 2]
+- ...
+
+---
+
+## Influences
+
+<!--
+Who and what shaped how you think.
+Books, people, concepts, experiences.
+Be specific about WHAT you took from each.
+-->
+
+### People
+- [Person]: What you learned from them
+- [Person]: What you learned from them
+
+### Books/Works
+- [Book/Work]: Key idea you took from it
+- [Book/Work]: Key idea you took from it
+
+### Concepts/Frameworks
+- [Concept]: How you use it
+- [Concept]: How you use it
+
+---
+
+## Vocabulary
+
+<!--
+Terms you use with specific meanings.
+Jargon, neologisms, references that need context.
+Skip this section if you don't have specialized vocabulary.
+-->
+
+- **[Term]**: What it means when you say it
+- **[Term]**: What it means when you say it
+
+---
+
+## Tensions & Contradictions
+
+<!--
+Optional but valuable.
+Real people have inconsistent views.
+What do you believe that's in tension with something else you believe?
+-->
+
+- [Tension 1]
+- [Tension 2]
+
+---
+
+## Pet Peeves
+
+<!--
+What annoys you? What do you push back against reflexively?
+These add texture and personality.
+-->
+
+- [Pet peeve]
+- [Pet peeve]
+
+---
+
+<!--
+QUALITY CHECK:
+- Could someone predict your take on a new topic from this? If not, add more.
+- Are your opinions specific enough to be wrong? If not, sharpen them.
+- Would a friend read this and say "yeah, that's you"? If not, what's missing?
+-->

package/dist/runtime/tinyclaw/scaffold.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeAgentScaffold } from "../types.js";
+export declare const createTinyClawAgentScaffold: () => RuntimeAgentScaffold;

package/dist/runtime/tinyclaw/scaffold.js

@@ -0,0 +1,24 @@
+import { createAgentScaffoldManifest } from "../../manifest/index.js";
+import { loadRuntimeScaffoldAsset } from "../scaffoldAssets.js";
+export const createTinyClawAgentScaffold = () => ({
+    files: [
+        {
+            content: loadRuntimeScaffoldAsset(import.meta.url, "SOUL.md"),
+            path: "SOUL.md"
+        },
+        {
+            content: loadRuntimeScaffoldAsset(import.meta.url, "AGENTS.md"),
+            path: "AGENTS.md"
+        }
+    ],
+    manifest: createAgentScaffoldManifest({
+        authMethod: "claude-code",
+        docs: {
+            soul: "SOUL.md",
+            system: "AGENTS.md"
+        },
+        modelName: "claude-sonnet-4-6",
+        provider: "anthropic",
+        runtime: "tinyclaw"
+    })
+});

package/dist/runtime/tinyclaw/surfaces.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedAgentSurfaces } from "../../compiler/types.js";
+import type { ContainerTarget, ContainerTargetInput } from "../types.js";
+export declare const buildTinyClawChannels: (surfaces: ResolvedAgentSurfaces | undefined) => {
+    config: Record<string, unknown>;
+    enabled: string[];
+};
+export declare const resolveTinyClawSurfaceTokenBindings: (inputs: ContainerTargetInput[]) => ContainerTarget["configEnvBindings"];
+export declare const assertSupportedTinyClawSurfaces: (surfaces: ResolvedAgentSurfaces | undefined) => void;