@guuey/config 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Loqu, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# @guuey/config
+
+Types, schema, and loader for `guuey.json` — the single config file that
+describes a [guuey](https://guuey.com) agent app: the agent (framework,
+prompt, model, runtime), its MCP servers (hosted / co-located / external),
+and its ggui generative-UI assets.
+
+```ts
+import { loadGuueyJson, safeParseGuueyJson } from "@guuey/config";
+
+const { doc } = loadGuueyJson(projectRoot);
+doc.agent.framework; // "claude-agent-sdk" | "openai-agents-sdk" | ...
+doc.agent.mcpServers; // { todo: { kind: "hosted", server: "mcp-..." }, ... }
+```
+
+The schema is the contract shared by `guuey dev`, `guuey deploy`, and the
+hosted runtime — one file, validated the same way everywhere. Scaffold a
+project that uses it with `npx @guuey/create-agentic-app`.

package/dist/agent-loader.d.ts

@@ -0,0 +1,65 @@
+import { AgentJsonV1 } from './agent.js';
+/**
+ * Walk up from `startDir` (default: `process.cwd()`) looking for an
+ * `agent.json`. Returns the absolute path to the first match, or
+ * `null` if no file is found within `maxDepth` levels.
+ *
+ * Stops at the filesystem root regardless of `maxDepth`. Never throws —
+ * a missing file is a valid result ("this repo is code-mode only"),
+ * not an error.
+ */
+export declare function findAgentJson(startDir?: string, maxDepth?: number): string | null;
+/**
+ * Error thrown when an `agent.json` fails to load — missing file,
+ * malformed JSON, schema validation failure, or an unresolvable
+ * `systemPrompt.file` reference. Wraps the underlying cause
+ * (`SyntaxError` / `ZodError` / filesystem error) on `.cause`.
+ */
+export declare class AgentJsonLoadError extends Error {
+    readonly path: string;
+    constructor(message: string, path: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * The inlined, ready-to-snapshot form of `agent.json`. Identical
+ * shape to {@link AgentJsonV1} EXCEPT `systemPrompt` is always
+ * `string | undefined` — file references are resolved and inlined
+ * during load. The pod runtime never reads the filesystem; it sees
+ * only this resolved shape.
+ *
+ * `undefined` system prompt means "fall through to the platform
+ * default" (see `GUUEY_DEFAULT_SYSTEM_PROMPT` in `./system-prompt`).
+ */
+export type ResolvedAgentJson = Omit<AgentJsonV1, 'systemPrompt'> & {
+    systemPrompt?: string;
+};
+/**
+ * Read `agent.json` at `path`, parse JSON, validate against v1, and
+ * inline any `systemPrompt.file` reference (resolved relative to the
+ * `agent.json` directory). Returns the fully-resolved snapshot.
+ *
+ * Throws {@link AgentJsonLoadError} if:
+ *   - the file does not exist,
+ *   - the file is not valid JSON,
+ *   - the document fails schema validation (cause = `ZodError`),
+ *   - `systemPrompt.file` points outside the project directory or
+ *     does not exist on disk.
+ */
+export declare function loadAgentJson(path: string): ResolvedAgentJson;
+/**
+ * Non-throwing variant of {@link loadAgentJson}. Returns a
+ * discriminated result mirroring `z.safeParse` for ergonomics in CLI
+ * surfaces that render the error inline.
+ */
+export type SafeLoadAgentResult = {
+    success: true;
+    data: ResolvedAgentJson;
+} | {
+    success: false;
+    error: AgentJsonLoadError;
+};
+export declare function safeLoadAgentJson(path: string): SafeLoadAgentResult;
+export { AGENT_JSON_FILENAME, AgentJsonV1, parseAgentJson, safeParseAgentJson, DEFAULT_AGENT_MCP_SERVERS, } from './agent.js';
+export type { AgentJsonMcpServer, AgentJsonRuntime, AgentJsonSystemPrompt, AgentJsonToolGates, } from './agent.js';
+//# sourceMappingURL=agent-loader.d.ts.map

package/dist/agent-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-loader.d.ts","sourceRoot":"","sources":["../src/agent-loader.ts"],"names":[],"mappings":"AAoBA,OAAO,EAEL,WAAW,EAEZ,MAAM,YAAY,CAAC;AAUpB;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,GAAE,MAAsB,EAChC,QAAQ,GAAE,MAA+B,GACxC,MAAM,GAAG,IAAI,CAUf;AAED;;;;;GAKG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE;CAKzE;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,WAAW,EAAE,cAAc,CAAC,GAAG;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CA8C7D;AAED;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAC1C;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAElD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CASnE;AAoDD,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,YAAY,CAAC"}

package/dist/agent-loader.js

@@ -0,0 +1,155 @@
+/**
+ * Node-only filesystem helpers for `agent.json`.
+ *
+ * Pure-parse helpers (`parseAgentJson` / `safeParseAgentJson`) live in
+ * `./agent.ts` and are safe to import from non-Node contexts. This
+ * module adds the file-resolution layer: reading `agent.json` off
+ * disk, inlining `systemPrompt.file` references, and producing the
+ * snapshot the deploy upload + pod boot both read.
+ *
+ * Intended callers:
+ *
+ * - `guuey` CLI: `guuey deploy --config agent.json` reads the file,
+ *   inlines the system prompt, and POSTs the resulting snapshot to
+ *   the control plane as the no-tarball declarative deploy body.
+ * - Guuey control-plane services that re-validate the submitted
+ *   snapshot server-side before persisting to AgentDeployment.
+ * - Stock nocode-runtime pod: reads the snapshot back at boot.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { AGENT_JSON_FILENAME, parseAgentJson, } from './agent.js';
+/**
+ * How many parent directories `findAgentJson` will walk by default.
+ * Internal — the public-facing constant of the same name on
+ * `./loader.ts` is the one re-exported on the package barrel; the
+ * two values are kept in sync intentionally.
+ */
+const DEFAULT_FIND_MAX_DEPTH = 8;
+/**
+ * Walk up from `startDir` (default: `process.cwd()`) looking for an
+ * `agent.json`. Returns the absolute path to the first match, or
+ * `null` if no file is found within `maxDepth` levels.
+ *
+ * Stops at the filesystem root regardless of `maxDepth`. Never throws —
+ * a missing file is a valid result ("this repo is code-mode only"),
+ * not an error.
+ */
+export function findAgentJson(startDir = process.cwd(), maxDepth = DEFAULT_FIND_MAX_DEPTH) {
+    let dir = resolve(startDir);
+    for (let i = 0; i <= maxDepth; i++) {
+        const candidate = join(dir, AGENT_JSON_FILENAME);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Error thrown when an `agent.json` fails to load — missing file,
+ * malformed JSON, schema validation failure, or an unresolvable
+ * `systemPrompt.file` reference. Wraps the underlying cause
+ * (`SyntaxError` / `ZodError` / filesystem error) on `.cause`.
+ */
+export class AgentJsonLoadError extends Error {
+    path;
+    constructor(message, path, options) {
+        super(message, options);
+        this.name = 'AgentJsonLoadError';
+        this.path = path;
+    }
+}
+/**
+ * Read `agent.json` at `path`, parse JSON, validate against v1, and
+ * inline any `systemPrompt.file` reference (resolved relative to the
+ * `agent.json` directory). Returns the fully-resolved snapshot.
+ *
+ * Throws {@link AgentJsonLoadError} if:
+ *   - the file does not exist,
+ *   - the file is not valid JSON,
+ *   - the document fails schema validation (cause = `ZodError`),
+ *   - `systemPrompt.file` points outside the project directory or
+ *     does not exist on disk.
+ */
+export function loadAgentJson(path) {
+    if (!existsSync(path)) {
+        throw new AgentJsonLoadError(`agent.json not found at ${path}`, path);
+    }
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf-8');
+    }
+    catch (cause) {
+        throw new AgentJsonLoadError(`Failed to read agent.json at ${path}`, path, { cause });
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(raw);
+    }
+    catch (cause) {
+        throw new AgentJsonLoadError(`agent.json at ${path} is not valid JSON`, path, { cause });
+    }
+    let parsed;
+    try {
+        parsed = parseAgentJson(decoded);
+    }
+    catch (cause) {
+        throw new AgentJsonLoadError(`agent.json at ${path} failed schema validation`, path, { cause });
+    }
+    const baseDir = dirname(path);
+    const resolvedPrompt = resolveSystemPrompt(parsed, baseDir, path);
+    const out = { ...parsed, systemPrompt: resolvedPrompt };
+    if (resolvedPrompt === undefined) {
+        delete out.systemPrompt;
+    }
+    return out;
+}
+export function safeLoadAgentJson(path) {
+    try {
+        return { success: true, data: loadAgentJson(path) };
+    }
+    catch (error) {
+        if (error instanceof AgentJsonLoadError) {
+            return { success: false, error };
+        }
+        throw error;
+    }
+}
+/**
+ * Resolve the `systemPrompt` field on a parsed `agent.json`. Returns
+ * `undefined` when the field is absent (caller falls through to the
+ * platform default). Inlines `{ file }` references relative to
+ * `baseDir`; rejects absolute paths and parent-directory escapes so
+ * the snapshot can't pull arbitrary host files into the deploy.
+ */
+function resolveSystemPrompt(doc, baseDir, agentJsonPath) {
+    const sp = doc.systemPrompt;
+    if (sp === undefined)
+        return undefined;
+    if (typeof sp === 'string')
+        return sp;
+    const relPath = sp.file;
+    if (isAbsolute(relPath)) {
+        throw new AgentJsonLoadError(`systemPrompt.file "${relPath}" must be a relative path, not absolute`, agentJsonPath);
+    }
+    const resolved = resolve(baseDir, relPath);
+    const baseResolved = resolve(baseDir);
+    if (!resolved.startsWith(baseResolved + '/') && resolved !== baseResolved) {
+        throw new AgentJsonLoadError(`systemPrompt.file "${relPath}" resolves outside the project directory`, agentJsonPath);
+    }
+    if (!existsSync(resolved)) {
+        throw new AgentJsonLoadError(`systemPrompt.file "${relPath}" does not exist (looked at ${resolved})`, agentJsonPath);
+    }
+    try {
+        return readFileSync(resolved, 'utf-8').trim();
+    }
+    catch (cause) {
+        throw new AgentJsonLoadError(`Failed to read systemPrompt.file "${relPath}"`, agentJsonPath, { cause });
+    }
+}
+// Re-export pure schema + types from the same subpath so Node callers
+// can do one import.
+export { AGENT_JSON_FILENAME, AgentJsonV1, parseAgentJson, safeParseAgentJson, DEFAULT_AGENT_MCP_SERVERS, } from './agent.js';

package/dist/agent.d.ts

@@ -0,0 +1,284 @@
+/**
+ * `guuey.json#agent` — the agent section.
+ *
+ * The agent section describes the deployable agent: framework + model
+ * + system prompt + MCP host config + platform-feature opt-ins + deploy
+ * config. Read by `@guuey/host` at pod boot to construct the framework
+ * adapter; read by `@guuey/cli` to validate before submitting a deploy.
+ *
+ * Lives inside `guuey.json` post-2026-05-25 platform-architecture merge
+ * (slice 7.2). Previously a separate `agent.json` file. See
+ * `docs/plans/2026-05-25-platform-architecture.md` §14.2 for the
+ * field-by-field migration.
+ *
+ * **Minimal valid section** (all other fields default):
+ *
+ * ```jsonc
+ * {
+ *   "framework": "claude-agent-sdk",
+ *   "model": "claude-sonnet-5",
+ *   "systemPrompt": { "file": "prompts/system.md" }
+ * }
+ * ```
+ *
+ * Defaults applied by the pod runtime when fields are absent:
+ * - `framework`   → `'claude-agent-sdk'`
+ * - `mcpServers`  → `{ ggui: { url: 'https://mcp.ggui.ai' } }` (platform default; declaring `mcpServers` REPLACES this — not merged)
+ * - `model`       → framework-chosen default (Claude SDK → `claude-sonnet-5`)
+ * - `systemPrompt`→ `GUUEY_DEFAULT_SYSTEM_PROMPT` from `./system-prompt`
+ * - `auth`        → `'anonymous'`
+ * - `memory`      → `'thread'`
+ * - `storage`     → `['user', 'app']`
+ * - `endpoint`    → `{ kind: 'invoke', streaming: true }`
+ * - `deploy`      → `{ size: 'xs', region: 'us-east-1' }`
+ *
+ * **Rules for extending:**
+ *
+ * 1. **Additive only within `schema: '1'` (top-level).** New optional fields on existing
+ *    objects are safe. Breaking changes bump the file-level `schema` to `'2'`.
+ * 2. **Framework-neutral by default.** Fields meaningful to only one adapter (e.g. Claude's
+ *    `permissions`, OpenAI's `tools.functions`) belong on a `framework`-scoped sub-block.
+ */
+import { z } from 'zod';
+/**
+ * Supported framework adapters. The pod runtime selects the matching
+ * `@guuey/framework-*` adapter at boot. `vanilla` skips the framework
+ * layer entirely — the agent loop is the bare Anthropic Messages API
+ * call with manual MCP tool wiring. Useful for benchmarking and for
+ * adapters not yet built.
+ */
+export declare const AGENT_FRAMEWORKS: readonly ["claude-agent-sdk", "openai-agents-sdk", "google-adk", "vanilla"];
+export type AgentFramework = (typeof AGENT_FRAMEWORKS)[number];
+/**
+ * A single MCP server entry inside `agent.mcpServers`.
+ *
+ * Discriminated union on `kind` — one slot per hosting mode:
+ * - `colocated` — stdio child inside the agent pod
+ * - `hosted`    — guuey-hosted registry MCP (Starter+)
+ * - `proxied`   — 3rd-party SaaS via mcp-proxy credential broker (v2)
+ * - `external`  — builder-hosted, reached by URL (plain or federated)
+ */
+declare const McpServerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"colocated">;
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hosted">;
+    server: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    devPort: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"proxied">;
+    connection: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    url: z.ZodURL;
+    transport: z.ZodOptional<z.ZodEnum<{
+        http: "http";
+        sse: "sse";
+    }>>;
+    federate: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devPort: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>], "kind">;
+/**
+ * Tool-gate block — allowlist applied first (intersect with what the MCP
+ * server advertises), then denylist subtracts. Tool names are MCP-namespaced
+ * (`"<server>.<tool>"`). Bare names match across all connected servers.
+ */
+declare const ToolGatesSchema: z.ZodObject<{
+    allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    denylist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * Runtime knobs the pod applies when constructing the framework adapter.
+ * All optional with framework-chosen defaults.
+ *
+ * - `maxTurns`     — cap on agent loop turns per user message. Stops runaway
+ *                    loops on misbehaving prompts. Default: framework default
+ *                    (Claude SDK = 25).
+ * - `temperature`  — model sampling temperature passthrough.
+ */
+declare const RuntimeConfigSchema: z.ZodObject<{
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/**
+ * System prompt — string inline OR `{ file: 'prompts/system.md' }`.
+ * File references are resolved relative to `guuey.json` by the loader,
+ * which inlines the file contents into the snapshot before deploy upload.
+ */
+declare const SystemPromptSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    file: z.ZodString;
+}, z.core.$strict>]>;
+/**
+ * Bedrock-style invocation endpoint config.
+ *
+ * `kind: 'invoke'` exposes `POST /agent/invoke` with multi-modal input and
+ * SSE response per `docs/plans/2026-05-25-platform-architecture.md` §6.
+ * Reserved for future endpoint kinds (`'connect'` for WebSocket bidirectional).
+ */
+declare const EndpointConfigSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodLiteral<"invoke">>;
+    streaming: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/**
+ * Deploy config — pod size + region.
+ *
+ * Lives inside the `agent` section (was top-level on the pre-merge `guuey.json`).
+ * Mirror shape on `guuey.mcp.json#mcpServer.deploy` (future) — same field set,
+ * same semantics, just attached to a different artifact.
+ *
+ * Latent fields like `tier`, `maxPods`, `idleTimeoutMinutes` exist on the
+ * AgentDeployment DDB model but are platform-managed (Reserved per design
+ * doc §14.3) — not exposed in user-facing config.
+ */
+declare const DeploySchema: z.ZodObject<{
+    size: z.ZodOptional<z.ZodEnum<{
+        xs: "xs";
+        sm: "sm";
+        md: "md";
+        lg: "lg";
+        xl: "xl";
+    }>>;
+    region: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * The agent section — composes runtime + platform features + deploy.
+ *
+ * Exported as a zod object so the top-level `GuueyJsonV1` schema (in
+ * `./schema.ts`) can nest it. Static type via {@link GuueyAgent}.
+ */
+export declare const AgentSectionV1: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        declarative: "declarative";
+    }>>;
+    framework: z.ZodOptional<z.ZodEnum<{
+        "claude-agent-sdk": "claude-agent-sdk";
+        "openai-agents-sdk": "openai-agents-sdk";
+        "google-adk": "google-adk";
+        vanilla: "vanilla";
+    }>>;
+    model: z.ZodOptional<z.ZodString>;
+    modelProvider: z.ZodOptional<z.ZodEnum<{
+        openai: "openai";
+        openrouter: "openrouter";
+    }>>;
+    systemPrompt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        file: z.ZodString;
+    }, z.core.$strict>]>>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"colocated">;
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"hosted">;
+        server: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodString>;
+        devPort: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"proxied">;
+        connection: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        url: z.ZodURL;
+        transport: z.ZodOptional<z.ZodEnum<{
+            http: "http";
+            sse: "sse";
+        }>>;
+        federate: z.ZodOptional<z.ZodBoolean>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        devPort: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "kind">>>;
+    tools: z.ZodOptional<z.ZodObject<{
+        allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        denylist: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    claude: z.ZodOptional<z.ZodObject<{
+        permissions: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                acceptEdits: "acceptEdits";
+                bypassPermissions: "bypassPermissions";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    auth: z.ZodOptional<z.ZodEnum<{
+        optional: "optional";
+        anonymous: "anonymous";
+        required: "required";
+    }>>;
+    memory: z.ZodOptional<z.ZodEnum<{
+        thread: "thread";
+        none: "none";
+    }>>;
+    storage: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        user: "user";
+        app: "app";
+    }>>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    endpoint: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodLiteral<"invoke">>;
+        streaming: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    deploy: z.ZodOptional<z.ZodObject<{
+        size: z.ZodOptional<z.ZodEnum<{
+            xs: "xs";
+            sm: "sm";
+            md: "md";
+            lg: "lg";
+            xl: "xl";
+        }>>;
+        region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Static TypeScript type derived from {@link AgentSectionV1}. */
+export type GuueyAgent = z.infer<typeof AgentSectionV1>;
+/** Single mcpServers entry type. */
+export type GuueyAgentMcpServer = z.infer<typeof McpServerSchema>;
+/** Tool-gate block type. */
+export type GuueyAgentToolGates = z.infer<typeof ToolGatesSchema>;
+/** Runtime-config block type. */
+export type GuueyAgentRuntime = z.infer<typeof RuntimeConfigSchema>;
+/** System-prompt shape (string or `{ file }`). */
+export type GuueyAgentSystemPrompt = z.infer<typeof SystemPromptSchema>;
+/** Endpoint config type. */
+export type GuueyAgentEndpoint = z.infer<typeof EndpointConfigSchema>;
+/** Deploy config type. */
+export type GuueyAgentDeploy = z.infer<typeof DeploySchema>;
+/**
+ * Validate that no `mcpServers[*].headers` value carries a LITERAL secret.
+ * Returns a list of human-readable violation messages (empty = clean).
+ *
+ * Two layers:
+ *  1. Strip `${env.NAME}` refs from each value, then match the literal
+ *     remainder against {@link SECRET_SHAPE_PATTERNS} → a baked secret in ANY
+ *     header (e.g. `Authorization: Bearer sk-ant-...`).
+ *  2. For {@link SENSITIVE_HEADER_NAMES}, a value with NO `${env.NAME}` ref and
+ *     a non-trivial literal (after removing scheme words) → a baked credential
+ *     (e.g. `X-API-Key: abc123`, `Authorization: Basic <base64>`).
+ *
+ * Legit ref-based values (`Authorization: Bearer ${env.TOKEN}`,
+ * `X-API-Key: ${env.KEY}`) and non-secret literals (`Content-Type`) pass.
+ */
+export declare function validateNoLiteralSecrets(agent: GuueyAgent | undefined): string[];
+/**
+ * Platform default MCP server map. Applied by the pod when `agent.mcpServers`
+ * is absent. Exposed here so non-pod consumers (CLI dry-run, lints) can show
+ * the effective shape without duplicating the literal.
+ *
+ * The ggui server is `kind: 'external'` — it is builder-declared when present
+ * or injected by the platform at runtime. Federation still detects it by host
+ * (via `isGguiUrl`) regardless of which key it's declared under.
+ */
+export declare const DEFAULT_AGENT_MCP_SERVERS: Record<string, GuueyAgentMcpServer>;
+export {};
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,6EAKnB,CAAC;AACX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAoF/D;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;4BAKnB,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,eAAe;;;kBAGnB,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB;;;kBAGvB,CAAC;AAcH;;;;GAIG;AACH,QAAA,MAAM,kBAAkB;;oBAGtB,CAAC;AAEH;;;;;;GAMG;AACH,QAAA,MAAM,oBAAoB;;;kBAGxB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,YAAY;;;;;;;;;kBAKhB,CAAC;AAsBH;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoEzB,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,oCAAoC;AACpC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAElE,4BAA4B;AAC5B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAElE,iCAAiC;AACjC,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEpE,kDAAkD;AAClD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAExE,4BAA4B;AAC5B,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEtE,0BAA0B;AAC1B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAuE5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,MAAM,EAAE,CAiCV;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAEzE,CAAC"}