@guuey/config 0.1.0

package/dist/mcp-servers.d.ts

@@ -0,0 +1,173 @@
+/**
+ * `mcpServers` — Guuey hosted overlay shape for relayed MCP server
+ * declarations.
+ *
+ * Relocated 2026-04-21 from `@ggui-ai/protocol/types/credential.ts`
+ * as part of the OSS split §8.2 classification fix (mirror of the
+ * 2026-04-21 `mcp-proxy` split). The `McpServerAuthConfig` type
+ * previously lived in the open protocol package with a docstring
+ * that said "Auth config in guuey.json mcpServers entries" — an
+ * overlay-shape type in an open package, exactly the pattern the
+ * mcp-proxy split closed.
+ *
+ * ## The classification decision
+ *
+ * `mcpServers` is the declaration block a developer adds to
+ * `guuey.json` to tell Guuey hosting: *"for this project, relay
+ * these HTTP MCP servers through the Guuey bridge, authenticating
+ * each via the credential stored under this `serviceId`."* That is
+ * platform-layer plumbing — the Guuey bridge registers the
+ * declaration with the Guuey-hosted WebSocket gateway, and the
+ * Guuey mcp-proxy Lambda resolves `auth.serviceId` against the
+ * platform's UserCredential store. An OSS-only `ggui serve`
+ * deployment has no analog for `auth.serviceId` because there is no
+ * Guuey credential store.
+ *
+ * Per §8.2: the OSS `ggui` server does NOT read `guuey.json`.
+ * Consumers that need this overlay value (the closed `guuey` CLI's
+ * `guuey dev` command, the closed `@guuey/bridge` package, Guuey-
+ * hosted Lambdas) are the only call sites allowed to import from
+ * this package. Open packages that historically read
+ * `McpServerAuthConfig` (`@ggui-ai/server`'s auth-relay code) now
+ * inline the minimal structural shape they actually use.
+ *
+ * ## Scope of this module
+ *
+ * - {@link CredentialInjection} + {@link CredentialInjectionConfig}
+ *   — runtime injection-mode descriptors, used here as
+ *   `McpServerAuth.injection` and also exported from
+ *   `@ggui-ai/protocol/types/credential.ts` for cloud-side runtime
+ *   consumers. The overlap is intentional and minor (10 lines of
+ *   literal-union type) — duplicating inline keeps this private
+ *   package dep-minimal (zod-only). If the two ever drift, the
+ *   consolidation fix is to add `@ggui-ai/protocol` as a workspace
+ *   dep here; today the duplication is cheaper than that cross-
+ *   boundary edge.
+ * - {@link McpServerAuthConfig} — auth block on a single
+ *   `mcpServers` entry. `serviceId` references the Guuey
+ *   credential store; `preInject` + `injection` tune how the relay
+ *   writes the placeholder.
+ * - {@link McpServerEntryConfig} — a single mcpServers entry
+ *   (`{ url, auth? }`). `url` is the HTTP MCP server endpoint.
+ * - {@link McpServersConfig} — the top-level record keyed by MCP
+ *   server name (`gmail`, `calendar`, future `slack`, …). Exactly
+ *   the shape `guuey.json#mcpServers` carries.
+ *
+ * ## Strictness
+ *
+ * Zod validation matches the rest of `guuey.json`: strict objects,
+ * non-empty strings, URL validation on `url`. Unknown keys on
+ * nested objects fail parse (prevents silent drift toward a "what
+ * else can we stuff into guuey.json" shape).
+ */
+import { z } from 'zod';
+/**
+ * Injection mode — how the Guuey mcp-proxy splices the resolved
+ * credential into the outbound HTTP request to the upstream MCP
+ * server. Duplicated minor from
+ * `@ggui-ai/protocol/types/credential.ts#CredentialInjection`; see
+ * module docstring for the duplication rationale.
+ */
+declare const CredentialInjectionSchema: z.ZodEnum<{
+    bearer_header: "bearer_header";
+    api_key_header: "api_key_header";
+    query_param: "query_param";
+    custom_header: "custom_header";
+}>;
+/** Full injection config — `mode` + per-mode tunables. */
+declare const CredentialInjectionConfigSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        bearer_header: "bearer_header";
+        api_key_header: "api_key_header";
+        query_param: "query_param";
+        custom_header: "custom_header";
+    }>;
+    headerName: z.ZodOptional<z.ZodString>;
+    paramName: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * Auth block on a single `mcpServers` entry. All fields are
+ * optional at the block level — a server without `auth` is relayed
+ * without credential injection (public MCP endpoint).
+ */
+declare const McpServerAuthSchema: z.ZodObject<{
+    serviceId: z.ZodString;
+    preInject: z.ZodOptional<z.ZodBoolean>;
+    injection: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            bearer_header: "bearer_header";
+            api_key_header: "api_key_header";
+            query_param: "query_param";
+            custom_header: "custom_header";
+        }>;
+        headerName: z.ZodOptional<z.ZodString>;
+        paramName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * A single `mcpServers` entry. `url` is the HTTP MCP server
+ * endpoint; `auth` scopes the credential injection.
+ */
+declare const McpServerEntrySchema: z.ZodObject<{
+    url: z.ZodURL;
+    auth: z.ZodOptional<z.ZodObject<{
+        serviceId: z.ZodString;
+        preInject: z.ZodOptional<z.ZodBoolean>;
+        injection: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                bearer_header: "bearer_header";
+                api_key_header: "api_key_header";
+                query_param: "query_param";
+                custom_header: "custom_header";
+            }>;
+            headerName: z.ZodOptional<z.ZodString>;
+            paramName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * The `mcpServers` section of `guuey.json`. Keys are MCP server
+ * display names (`gmail`, `calendar`, future `slack`, …) —
+ * arbitrary strings, by design. New servers are additive; a fixed
+ * literal union would force a schema change every time a new MCP
+ * server integration lands.
+ */
+export declare const McpServersSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    url: z.ZodURL;
+    auth: z.ZodOptional<z.ZodObject<{
+        serviceId: z.ZodString;
+        preInject: z.ZodOptional<z.ZodBoolean>;
+        injection: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodEnum<{
+                bearer_header: "bearer_header";
+                api_key_header: "api_key_header";
+                query_param: "query_param";
+                custom_header: "custom_header";
+            }>;
+            headerName: z.ZodOptional<z.ZodString>;
+            paramName: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>>;
+/** Runtime injection-mode descriptor type. */
+export type CredentialInjection = z.infer<typeof CredentialInjectionSchema>;
+/** Injection-config block type. */
+export type CredentialInjectionConfig = z.infer<typeof CredentialInjectionConfigSchema>;
+/** Auth-block type on an `mcpServers` entry. */
+export type McpServerAuthConfig = z.infer<typeof McpServerAuthSchema>;
+/** Single-entry type inside the `mcpServers` record. */
+export type McpServerEntryConfig = z.infer<typeof McpServerEntrySchema>;
+/** Full `mcpServers` overlay type derived from the zod schema. */
+export type McpServersConfig = z.infer<typeof McpServersSchema>;
+/**
+ * Parse a raw JSON value into a validated {@link McpServersConfig}.
+ * Throws a `ZodError` on invalid input.
+ */
+export declare function parseMcpServers(raw: unknown): McpServersConfig;
+/** Safe-parse variant — see {@link parseMcpServers}. */
+export declare function safeParseMcpServers(raw: unknown): ReturnType<typeof McpServersSchema.safeParse>;
+export {};
+//# sourceMappingURL=mcp-servers.d.ts.map

package/dist/mcp-servers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-servers.d.ts","sourceRoot":"","sources":["../src/mcp-servers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;GAMG;AACH,QAAA,MAAM,yBAAyB;;;;;EAK7B,CAAC;AAEH,0DAA0D;AAC1D,QAAA,MAAM,+BAA+B;;;;;;;;;kBAMnC,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;kBA4BvB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;kBAKxB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;mBAG5B,CAAC;AAEF,8CAA8C;AAC9C,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,mCAAmC;AACnC,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,+BAA+B,CACvC,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEtE,wDAAwD;AACxD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,kEAAkE;AAClE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAE9D;AAED,wDAAwD;AACxD,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,gBAAgB,CAAC,SAAS,CAAC,CAE/C"}

package/dist/mcp-servers.js

@@ -0,0 +1,147 @@
+/**
+ * `mcpServers` — Guuey hosted overlay shape for relayed MCP server
+ * declarations.
+ *
+ * Relocated 2026-04-21 from `@ggui-ai/protocol/types/credential.ts`
+ * as part of the OSS split §8.2 classification fix (mirror of the
+ * 2026-04-21 `mcp-proxy` split). The `McpServerAuthConfig` type
+ * previously lived in the open protocol package with a docstring
+ * that said "Auth config in guuey.json mcpServers entries" — an
+ * overlay-shape type in an open package, exactly the pattern the
+ * mcp-proxy split closed.
+ *
+ * ## The classification decision
+ *
+ * `mcpServers` is the declaration block a developer adds to
+ * `guuey.json` to tell Guuey hosting: *"for this project, relay
+ * these HTTP MCP servers through the Guuey bridge, authenticating
+ * each via the credential stored under this `serviceId`."* That is
+ * platform-layer plumbing — the Guuey bridge registers the
+ * declaration with the Guuey-hosted WebSocket gateway, and the
+ * Guuey mcp-proxy Lambda resolves `auth.serviceId` against the
+ * platform's UserCredential store. An OSS-only `ggui serve`
+ * deployment has no analog for `auth.serviceId` because there is no
+ * Guuey credential store.
+ *
+ * Per §8.2: the OSS `ggui` server does NOT read `guuey.json`.
+ * Consumers that need this overlay value (the closed `guuey` CLI's
+ * `guuey dev` command, the closed `@guuey/bridge` package, Guuey-
+ * hosted Lambdas) are the only call sites allowed to import from
+ * this package. Open packages that historically read
+ * `McpServerAuthConfig` (`@ggui-ai/server`'s auth-relay code) now
+ * inline the minimal structural shape they actually use.
+ *
+ * ## Scope of this module
+ *
+ * - {@link CredentialInjection} + {@link CredentialInjectionConfig}
+ *   — runtime injection-mode descriptors, used here as
+ *   `McpServerAuth.injection` and also exported from
+ *   `@ggui-ai/protocol/types/credential.ts` for cloud-side runtime
+ *   consumers. The overlap is intentional and minor (10 lines of
+ *   literal-union type) — duplicating inline keeps this private
+ *   package dep-minimal (zod-only). If the two ever drift, the
+ *   consolidation fix is to add `@ggui-ai/protocol` as a workspace
+ *   dep here; today the duplication is cheaper than that cross-
+ *   boundary edge.
+ * - {@link McpServerAuthConfig} — auth block on a single
+ *   `mcpServers` entry. `serviceId` references the Guuey
+ *   credential store; `preInject` + `injection` tune how the relay
+ *   writes the placeholder.
+ * - {@link McpServerEntryConfig} — a single mcpServers entry
+ *   (`{ url, auth? }`). `url` is the HTTP MCP server endpoint.
+ * - {@link McpServersConfig} — the top-level record keyed by MCP
+ *   server name (`gmail`, `calendar`, future `slack`, …). Exactly
+ *   the shape `guuey.json#mcpServers` carries.
+ *
+ * ## Strictness
+ *
+ * Zod validation matches the rest of `guuey.json`: strict objects,
+ * non-empty strings, URL validation on `url`. Unknown keys on
+ * nested objects fail parse (prevents silent drift toward a "what
+ * else can we stuff into guuey.json" shape).
+ */
+import { z } from 'zod';
+/**
+ * Injection mode — how the Guuey mcp-proxy splices the resolved
+ * credential into the outbound HTTP request to the upstream MCP
+ * server. Duplicated minor from
+ * `@ggui-ai/protocol/types/credential.ts#CredentialInjection`; see
+ * module docstring for the duplication rationale.
+ */
+const CredentialInjectionSchema = z.enum([
+    'bearer_header',
+    'api_key_header',
+    'query_param',
+    'custom_header',
+]);
+/** Full injection config — `mode` + per-mode tunables. */
+const CredentialInjectionConfigSchema = z.strictObject({
+    mode: CredentialInjectionSchema,
+    /** Header name for `api_key_header` / `custom_header`. Default: `X-API-Key`. */
+    headerName: z.string().min(1).optional(),
+    /** Query param name for `query_param`. Default: `api_key`. */
+    paramName: z.string().min(1).optional(),
+});
+/**
+ * Auth block on a single `mcpServers` entry. All fields are
+ * optional at the block level — a server without `auth` is relayed
+ * without credential injection (public MCP endpoint).
+ */
+const McpServerAuthSchema = z.strictObject({
+    /**
+     * Service ID referenced against the Guuey platform's
+     * UserCredential store. This is a Guuey-platform concept — an
+     * OSS-only deployment has no equivalent lookup.
+     */
+    serviceId: z.string().min(1),
+    /**
+     * Pre-inject placeholder before the first upstream request
+     * (skips the 401 → consent → retry dance for cases where the
+     * user has already linked the credential). Default: `false`.
+     */
+    preInject: z.boolean().optional(),
+    /**
+     * Override the injection mode. Falls back to the
+     * `McpServiceConfig` table entry keyed by `serviceId`, which
+     * defaults to `bearer_header`.
+     */
+    injection: CredentialInjectionConfigSchema.optional(),
+    /**
+     * Optional OAuth scope hint forwarded to the hosted bridge at
+     * connect time. The platform consumes this when minting tokens
+     * against the upstream MCP server. Preserved here (2026-04-21)
+     * for wire-compat with `@guuey/bridge`'s existing inline shape,
+     * which flows `auth.scopes` through the bridge WebSocket config
+     * message.
+     */
+    scopes: z.array(z.string().min(1)).optional(),
+});
+/**
+ * A single `mcpServers` entry. `url` is the HTTP MCP server
+ * endpoint; `auth` scopes the credential injection.
+ */
+const McpServerEntrySchema = z.strictObject({
+    /** HTTP MCP server endpoint. */
+    url: z.url(),
+    /** Optional auth block — omit for public endpoints. */
+    auth: McpServerAuthSchema.optional(),
+});
+/**
+ * The `mcpServers` section of `guuey.json`. Keys are MCP server
+ * display names (`gmail`, `calendar`, future `slack`, …) —
+ * arbitrary strings, by design. New servers are additive; a fixed
+ * literal union would force a schema change every time a new MCP
+ * server integration lands.
+ */
+export const McpServersSchema = z.record(z.string().min(1), McpServerEntrySchema);
+/**
+ * Parse a raw JSON value into a validated {@link McpServersConfig}.
+ * Throws a `ZodError` on invalid input.
+ */
+export function parseMcpServers(raw) {
+    return McpServersSchema.parse(raw);
+}
+/** Safe-parse variant — see {@link parseMcpServers}. */
+export function safeParseMcpServers(raw) {
+    return McpServersSchema.safeParse(raw);
+}

package/dist/registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Model + framework registry — single source of truth per the model-release
+ * playbook §8 item A; a release = one entry change here + rate-card row.
+ */
+export type ModelStatus = "ga" | "preview" | "announced" | "deprecated";
+export interface ModelEntry {
+    readonly id: string;
+    readonly provider: "anthropic" | "openai" | "google" | "openrouter";
+    readonly label: string;
+    readonly status: ModelStatus;
+    readonly isDefault?: true;
+    readonly sunset?: string;
+}
+export interface FrameworkEntry {
+    readonly framework: "claude-agent-sdk" | "openai-agents-sdk" | "google-adk" | "vanilla";
+    readonly sdkPackage: string | null;
+    readonly platformPinnedVersion: string | null;
+    readonly facetSupportedRange: string | null;
+    readonly defaultProvider: "anthropic" | "openai" | "google";
+}
+export declare const MODEL_REGISTRY: readonly ModelEntry[];
+export declare const FRAMEWORK_REGISTRY: readonly FrameworkEntry[];
+/**
+ * Get all models for a provider, filtered to ga|preview only, with default first.
+ */
+export declare function modelsForProvider(p: ModelEntry["provider"]): readonly ModelEntry[];
+/**
+ * Get the default model id for a framework's default provider.
+ */
+export declare function defaultModelFor(framework: FrameworkEntry["framework"]): string;
+/**
+ * Look up a model entry by id.
+ */
+export declare function modelEntry(id: string): ModelEntry | undefined;
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAC;IACpE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAC;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,eAAe,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC7D;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,UAAU,EAe/C,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,SAAS,cAAc,EA6BvD,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,SAAS,UAAU,EAAE,CAQlF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,GAAG,MAAM,CAM9E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAE7D"}

package/dist/registry.js

@@ -0,0 +1,80 @@
+/**
+ * Model + framework registry — single source of truth per the model-release
+ * playbook §8 item A; a release = one entry change here + rate-card row.
+ */
+export const MODEL_REGISTRY = [
+    { id: "claude-sonnet-5", provider: "anthropic", label: "Claude Sonnet 5", status: "ga", isDefault: true },
+    { id: "claude-fable-5", provider: "anthropic", label: "Claude Fable 5", status: "ga" },
+    { id: "claude-sonnet-4-6", provider: "anthropic", label: "Claude Sonnet 4.6", status: "ga" },
+    { id: "claude-haiku-4-5", provider: "anthropic", label: "Claude Haiku 4.5", status: "ga" },
+    { id: "claude-opus-4-8", provider: "anthropic", label: "Claude Opus 4.8", status: "ga" },
+    { id: "gpt-5.5", provider: "openai", label: "GPT-5.5", status: "ga", isDefault: true },
+    { id: "gpt-5.4", provider: "openai", label: "GPT-5.4", status: "ga" },
+    { id: "gpt-4o", provider: "openai", label: "GPT-4o", status: "ga" },
+    { id: "gpt-4o-mini", provider: "openai", label: "GPT-4o Mini", status: "ga" },
+    { id: "gpt-5.6", provider: "openai", label: "GPT-5.6", status: "announced" },
+    { id: "gemini-3.5-flash", provider: "google", label: "Gemini 3.5 Flash", status: "ga", isDefault: true },
+    { id: "gemini-3.1-pro", provider: "google", label: "Gemini 3.1 Pro", status: "ga" },
+    { id: "gemini-2.5-flash", provider: "google", label: "Gemini 2.5 Flash", status: "ga" },
+    { id: "gemini-2.5-pro", provider: "google", label: "Gemini 2.5 Pro", status: "ga" },
+];
+export const FRAMEWORK_REGISTRY = [
+    {
+        framework: "claude-agent-sdk",
+        sdkPackage: "@anthropic-ai/claude-agent-sdk",
+        platformPinnedVersion: "0.3.199",
+        facetSupportedRange: ">=0.2.76 <0.4",
+        defaultProvider: "anthropic",
+    },
+    {
+        framework: "openai-agents-sdk",
+        sdkPackage: "@openai/agents",
+        platformPinnedVersion: "0.12.0",
+        facetSupportedRange: ">=0.2.0 <0.13",
+        defaultProvider: "openai",
+    },
+    {
+        framework: "google-adk",
+        sdkPackage: "google-adk",
+        platformPinnedVersion: "2.3.0",
+        facetSupportedRange: null,
+        defaultProvider: "google",
+    },
+    {
+        framework: "vanilla",
+        sdkPackage: null,
+        platformPinnedVersion: null,
+        facetSupportedRange: null,
+        defaultProvider: "anthropic",
+    },
+];
+/**
+ * Get all models for a provider, filtered to ga|preview only, with default first.
+ */
+export function modelsForProvider(p) {
+    return MODEL_REGISTRY.filter((m) => m.provider === p && (m.status === "ga" || m.status === "preview")).sort((a, b) => {
+        if (a.isDefault)
+            return -1;
+        if (b.isDefault)
+            return 1;
+        return 0;
+    });
+}
+/**
+ * Get the default model id for a framework's default provider.
+ */
+export function defaultModelFor(framework) {
+    const fw = FRAMEWORK_REGISTRY.find((f) => f.framework === framework);
+    if (!fw)
+        throw new Error(`Unknown framework: ${framework}`);
+    const model = MODEL_REGISTRY.find((m) => m.provider === fw.defaultProvider && m.isDefault && m.status === "ga");
+    if (!model)
+        throw new Error(`No default ga model for provider: ${fw.defaultProvider}`);
+    return model.id;
+}
+/**
+ * Look up a model entry by id.
+ */
+export function modelEntry(id) {
+    return MODEL_REGISTRY.find((m) => m.id === id);
+}

package/dist/schema.d.ts

@@ -0,0 +1,204 @@
+/**
+ * `guuey.json` v1 — the merged platform config.
+ *
+ * Single source of truth for a guuey-deployed project. Composed of:
+ *
+ * - `agent` (required for agent deploys) — declarative runtime + deploy config
+ * - `app`   (optional) — App Store / Portal listing metadata
+ * - `ggui`  (optional) — cross-protocol integration if the agent uses ggui rendering
+ *
+ * Plus top-level platform identity (`appId`, `workspaceId`) populated by
+ * the CLI after `guuey create` / `guuey link`.
+ *
+ * **Filename convention** (filename = artifact kind, see design doc §3):
+ * ```
+ * guuey.json       ← agent deploy (this file's schema)
+ * guuey.mcp.json   ← MCP server deploy (separate schema — see guuey-mcp.ts when added)
+ * ```
+ *
+ * **History.** Pre-2026-05-25 the repo carried two separate files:
+ *   - `agent.json` — runtime contract (slice 2.0)
+ *   - `guuey.json` — hosted overlay (project, deploy, deployments, mcpProxies, mcpServers)
+ *
+ * Slice 7.2 (2026-05-25) merged them per platform-architecture design doc §3.1
+ * + §14.2 field-by-field migration table. Pre-launch no-backcompat rule —
+ * the old shape is GONE, not deprecated.
+ *
+ * **Minimum valid `guuey.json`** (every other field defaults):
+ *
+ * ```jsonc
+ * {
+ *   "schema": "1",
+ *   "agent": {
+ *     "framework": "claude-agent-sdk",
+ *     "model": "claude-sonnet-4-6",
+ *     "systemPrompt": { "file": "prompts/system.md" }
+ *   }
+ * }
+ * ```
+ */
+import { z } from 'zod';
+import { type GuueyAgent } from './agent.js';
+import { type GuueyApp } from './app.js';
+import { type GuueyGguiSection } from './ggui.js';
+/**
+ * Top-level guuey.json v1 schema.
+ *
+ * `agent` is required — there's no "empty" guuey.json. A repo that hosts
+ * only an MCP server uses `guuey.mcp.json` instead (separate schema).
+ *
+ * `appId` and `workspaceId` are platform-resolved identifiers stamped by
+ * the CLI after `guuey create` / `guuey link`. A fresh project has neither.
+ * After first `guuey create`, both may be present.
+ *
+ * Re-exports the sub-section types for consumer convenience.
+ */
+export declare const GuueyJsonV1: z.ZodObject<{
+    schema: z.ZodLiteral<"1">;
+    appId: z.ZodOptional<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    agent: 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>;
+    app: z.ZodOptional<z.ZodObject<{
+        slug: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        iconUrl: z.ZodOptional<z.ZodURL>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        customDomain: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    ggui: z.ZodOptional<z.ZodObject<{
+        appId: z.ZodOptional<z.ZodString>;
+        configFile: z.ZodOptional<z.ZodString>;
+        inline: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    worker: z.ZodOptional<z.ZodString>;
+    protocol: z.ZodDefault<z.ZodEnum<{
+        silver: "silver";
+        bypass: "bypass";
+    }>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        router: z.ZodDefault<z.ZodEnum<{
+            v1: "v1";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Static TypeScript type for `guuey.json` v1. */
+export type GuueyJsonV1 = z.infer<typeof GuueyJsonV1>;
+/**
+ * Author-side shape for `guuey.json` v1 — what a writer may construct before
+ * `parseGuueyJson` applies schema defaults (e.g. `protocol` → `'silver'`).
+ * Fields with defaults are optional here and required on {@link GuueyJsonV1}.
+ */
+export type GuueyJsonV1Input = z.input<typeof GuueyJsonV1>;
+export type { GuueyAgent, GuueyApp, GuueyGguiSection };
+/**
+ * Canonical filename — always at the project root, always this name.
+ * Exported so tooling uses the same constant instead of hard-coding.
+ */
+export declare const GUUEY_JSON_FILENAME = "guuey.json";
+/**
+ * Parse a raw JSON value into a validated {@link GuueyJsonV1}.
+ * Throws a `ZodError` with human-readable issues on invalid input.
+ *
+ * Callers must have already JSON-decoded the source. Does NOT resolve
+ * `agent.systemPrompt.file` references — that's the loader's job (see
+ * `./loader.ts#loadGuueyJson`). Pure parse is safe to run anywhere;
+ * file resolution requires a base directory and is Node-only.
+ */
+export declare function parseGuueyJson(raw: unknown): GuueyJsonV1;
+/**
+ * Safe-parse variant — returns a discriminated `z.safeParse` result.
+ * Prefer this inside CLI tooling where you want to render the issue
+ * list without try/catch.
+ */
+export declare function safeParseGuueyJson(raw: unknown): ReturnType<typeof GuueyJsonV1.safeParse>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDtB,CAAC;AAEH,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAG3D,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAExD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,WAAW,CAAC,SAAS,CAAC,CAE1C"}