@ggui-ai/ui-gen 0.8.0 → 0.10.0

package/src/provider-adapter.ts

@@ -1,7 +1,18 @@
 /**
  * Provider adapter contract — the narrow surface every concrete LLM
- * provider client (Anthropic, Google, OpenAI, OpenRouter) implements
- * before the generator wires them in.
+ * provider client (Anthropic, Google, OpenAI, OpenRouter, Bedrock)
+ * implements.
+ *
+ * **Real role:** a provider-agnostic one-shot LLM caller for
+ * lightweight callers that need a single `complete()` round-trip — NOT
+ * a generation harness. The primary consumer is the negotiator's LLM
+ * seam (`@ggui-ai/mcp-server`'s `llm-backed-negotiator.ts`, via
+ * {@link selectAdapter} from `./providers/index.js`); other lightweight
+ * one-shot callers use it the same way. It is explicitly NOT part of
+ * the generation dispatch path: `createUiGenerator()` accepts no
+ * adapter option, and generation-call 429 retry/backoff lives entirely
+ * in `harness/llm-router.ts`'s `apiCall()` — a separate retry story for
+ * a separate call shape (an agentic SDK loop, not a single completion).
  *
  * The contract is deliberately defined independently of concrete
  * adapters so:
@@ -9,10 +20,9 @@
  *   - Adapter implementations can be written against a stable surface —
  *     every concrete adapter MUST pass
  *     {@link providerAdapterContract} or it isn't a `ProviderAdapter`.
- *   - Downstream callers (`createUiGenerator`, render handlers, retry /
- *     backoff plumbing) build against ONE structured failure shape
- *     ({@link ProviderError}) instead of inventing per-provider error
- *     UX.
+ *   - Downstream one-shot callers build against ONE structured failure
+ *     shape ({@link ProviderError}) instead of inventing per-provider
+ *     error UX.
  *   - The negotiator + cache layers can branch on
  *     `error.kind === 'rate-limited'` etc. without parsing strings.
  *

package/src/providers/bedrock.ts

@@ -7,8 +7,8 @@
  *
  * ## Why this adapter exists
  *
- * Anyone running the generator on an AWS-credentialed host (EC2, ECS,
- * Lambda, EKS) can target Bedrock without managing API keys: IAM is
+ * Anyone running a one-shot LLM caller on an AWS-credentialed host
+ * (EC2, ECS, Lambda, EKS) can target Bedrock without managing API keys: IAM is
  * the auth boundary, AWS rotates host credentials automatically, and
  * a misconfigured IAM role surfaces as a clear `AccessDeniedException`
  * the SDK funnels through `mapError`. The alternative — parking a
@@ -50,19 +50,29 @@
  * discriminator if a third auth mode (e.g. cross-account assume-role)
  * lands.
  *
- * ## Model IDs — pass-through
+ * ## Model IDs — pass-through, endpoint chosen by ID shape
  *
- * Bedrock and the direct Anthropic API use OVERLAPPING but DISTINCT
- * model id namespaces:
+ * Bedrock serves Anthropic models through TWO endpoints with DISJOINT
+ * model-id namespaces (live-probed against us-east-1, 2026-08-13):
  *
- *   - Direct API: `claude-haiku-4-5`, `claude-opus-4-7`, etc.
- *   - Bedrock foundation models: `anthropic.claude-sonnet-4-6`
- *   - Bedrock cross-region inference profiles: `us.anthropic.claude-haiku-4-5-20251001-v1:0`
+ *   - **bedrock-runtime** (`AnthropicBedrock`): serves ONLY
+ *     cross-region inference-profile ids —
+ *     `us.anthropic.claude-haiku-4-5-20251001-v1:0` etc. Bare
+ *     `anthropic.*` foundation ids are rejected with 400
+ *     "on-demand throughput isn't supported".
+ *   - **Messages-API endpoint / Mantle** (`AnthropicBedrockMantle`):
+ *     serves ONLY region-less `anthropic.*` ids —
+ *     `anthropic.claude-opus-5`, `anthropic.claude-haiku-4-5`. The
+ *     Claude 5 family and Opus 4.8 exist ONLY here. Profile ids are
+ *     rejected with 404. Requires the account to have enabled Claude
+ *     in Amazon Bedrock (otherwise every id 403s "not available for
+ *     this account").
  *
- * The adapter passes whatever `request.model` contains straight to
- * Bedrock — translation lives in the caller (model picker / deployment
- * config). Supply a Bedrock foundation-model or inference-profile id,
- * not a direct-API model name.
+ * Because the namespaces never overlap, the adapter routes each
+ * request by shape: ids starting `anthropic.` go to Mantle, region-
+ * prefixed ids (`us.` / `eu.` / `apac.` / `global.`) go to
+ * bedrock-runtime. The id itself passes through untranslated —
+ * supply a Bedrock id, not a direct-API model name.
  *
  * ## Failure mapping
  *
@@ -87,7 +97,7 @@
  * subclasses in the SDK, distinguished by `.status` (403 / 429 / 400
  * respectively).
  */
-import { AnthropicBedrock } from '@anthropic-ai/bedrock-sdk';
+import { AnthropicBedrock, AnthropicBedrockMantle } from '@anthropic-ai/bedrock-sdk';
 import type { LlmProvider } from '@ggui-ai/mcp-server-core';
 import {
   makeProviderError,
@@ -110,6 +120,47 @@ import { classifyFetchError } from './http.js';
 const PROVIDER: LlmProvider = 'bedrock';
 const DEFAULT_MAX_TOKENS = 4096;
 
+/**
+ * Which Bedrock endpoint a model id resolves to. The namespaces are
+ * disjoint (see the docstring above), so the shape of the id fully
+ * determines the endpoint — no configuration knob needed.
+ */
+export type BedrockEndpoint = 'runtime' | 'mantle';
+
+/**
+ * Structural slice of the two SDK clients the adapter actually drives —
+ * the seam that lets tests inject a stub without standing up a real
+ * AWS client. Both `AnthropicBedrock` and `AnthropicBedrockMantle`
+ * satisfy it (the adapter's single-completion contract only ever calls
+ * non-streaming `messages.create`; the response is parsed from
+ * `unknown` by `parseAnthropicMessagesResponse`, so the SDK's
+ * version-volatile `Message` type is deliberately not part of the
+ * seam).
+ */
+export interface BedrockMessagesClient {
+  readonly messages: {
+    create(
+      body: {
+        model: string;
+        max_tokens: number;
+        system?: string;
+        messages: Array<{ role: 'user'; content: string }>;
+      },
+      options?: { signal?: AbortSignal },
+    ): Promise<unknown>;
+  };
+}
+
+/**
+ * Route a Bedrock model id to its serving endpoint. Region-less
+ * `anthropic.*` ids exist only on the Messages-API (Mantle) endpoint;
+ * everything else (region-prefixed inference profiles, ARNs) belongs
+ * to bedrock-runtime.
+ */
+export function bedrockEndpointFor(model: string): BedrockEndpoint {
+  return model.startsWith('anthropic.') ? 'mantle' : 'runtime';
+}
+
 /**
  * Constructor options for the Bedrock adapter.
  *
@@ -130,11 +181,16 @@ export interface BedrockAdapterOptions {
   readonly region?: string;
   /**
    * Optional client factory override — used by tests to inject a
-   * mock or stub `AnthropicBedrock` client without actually hitting
-   * AWS. Production callers leave this unset; the adapter constructs
-   * the real client lazily on first `complete(...)` call.
+   * mock or stub client without actually hitting AWS. Called with the
+   * endpoint the request's model id routed to (`'runtime'` →
+   * `AnthropicBedrock`, `'mantle'` → `AnthropicBedrockMantle`).
+   * Production callers leave this unset; the adapter constructs the
+   * real client lazily on first `complete(...)` call per endpoint.
    */
-  readonly clientFactory?: (region: string) => AnthropicBedrock;
+  readonly clientFactory?: (
+    region: string,
+    endpoint: BedrockEndpoint,
+  ) => BedrockMessagesClient;
 }
 
 /**
@@ -142,21 +198,28 @@ export interface BedrockAdapterOptions {
  *
  * No API key — IAM is the auth boundary. The returned `ProviderAdapter`
  * satisfies the same contract as `createAnthropicAdapter`, so it
- * slots into `createUiGenerator({ adapter })` interchangeably (modulo
- * the per-provider model-id namespace differences).
+ * slots into any one-shot `ProviderAdapter` caller (e.g. `selectAdapter`)
+ * interchangeably (modulo the per-provider model-id namespace
+ * differences).
  */
 export function createBedrockAdapter(
   options: BedrockAdapterOptions = {},
 ): ProviderAdapter {
   const region = options.region ?? process.env['AWS_REGION'] ?? 'us-east-1';
   const clientFactory =
-    options.clientFactory ?? ((r: string) => new AnthropicBedrock({ awsRegion: r }));
+    options.clientFactory ??
+    ((r: string, endpoint: BedrockEndpoint): BedrockMessagesClient =>
+      endpoint === 'mantle'
+        ? new AnthropicBedrockMantle({ awsRegion: r })
+        : new AnthropicBedrock({ awsRegion: r }));
 
-  let cachedClient: AnthropicBedrock | null = null;
-  function getClient(): AnthropicBedrock {
-    if (cachedClient) return cachedClient;
-    cachedClient = clientFactory(region);
-    return cachedClient;
+  const cachedClients: Partial<Record<BedrockEndpoint, BedrockMessagesClient>> = {};
+  function getClient(endpoint: BedrockEndpoint): BedrockMessagesClient {
+    const cached = cachedClients[endpoint];
+    if (cached) return cached;
+    const created = clientFactory(region, endpoint);
+    cachedClients[endpoint] = created;
+    return created;
   }
 
   function mapError(raw: unknown): ProviderError {
@@ -218,7 +281,7 @@ export function createBedrockAdapter(
         };
       }
 
-      const client = getClient();
+      const client = getClient(bedrockEndpointFor(request.route.model));
       // The SDK's `Message` return type drifts between
       // `@anthropic-ai/sdk` versions (pnpm hoists multiple copies in
       // this workspace today). We type the captured value as

package/src/providers/index.ts

@@ -5,6 +5,15 @@
  * providers ggui supports today: Anthropic (direct API), Google,
  * OpenAI, OpenRouter, and AWS Bedrock (Anthropic models via IAM).
  *
+ * **Real role:** a provider-agnostic one-shot LLM caller for
+ * lightweight callers that need a single `complete()` round-trip — NOT
+ * the generation dispatch path. `createUiGenerator()` accepts no
+ * adapter option; generation-call retry/backoff lives entirely in
+ * `harness/llm-router.ts`'s `apiCall()`. The primary consumer is the
+ * negotiator's LLM seam (`@ggui-ai/mcp-server`'s
+ * `llm-backed-negotiator.ts`, via {@link selectAdapter}); other
+ * lightweight one-shot callers use it the same way.
+ *
  * Every adapter satisfies the structural
  * {@link import('../provider-adapter.js').ProviderAdapter} contract.
  * The four direct-API adapters compose
@@ -15,15 +24,18 @@
  * because rolling our own AWS SigV4 signer for one provider isn't a
  * reasonable trade.
  *
- * Typical usage from the CLI:
+ * Typical usage — a one-shot completion:
  *
  *   ```ts
  *   import { createAnthropicAdapter } from '@ggui-ai/ui-gen/providers';
- *   import { createUiGenerator } from '@ggui-ai/ui-gen';
  *
  *   const adapter = createAnthropicAdapter();
- *   const generator = createUiGenerator({ adapter });
- *   const result = await generator.generate({ request, llm, providerKey, blueprints });
+ *   const result = await adapter.complete({
+ *     apiKey,
+ *     route: { provider: 'anthropic', model: 'claude-haiku-4-5-20251001' },
+ *     systemPrompt,
+ *     userPrompt,
+ *   });
  *   ```
  *
  * Bedrock pool path (no API key — IAM at process boot):

package/src/tools/render-check.ts

@@ -28,7 +28,12 @@ import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { runSandboxed } from '@ggui-ai/sandbox';
-import type { PropsSpec, JsonObject, JsonValue } from '@ggui-ai/protocol';
+import type {
+  JsonObject,
+  JsonSchema,
+  JsonValue,
+  PropsSpec,
+} from '@ggui-ai/protocol';
 
 /**
  * Generate sample props from a PropsSpec contract.
@@ -58,21 +63,28 @@ export function generateSampleProps(spec: PropsSpec): JsonObject {
   return props;
 }
 
-function synthesizeFromSchema(schema: { type?: string; items?: unknown; properties?: JsonObject; required?: string[] }): JsonValue | undefined {
-  switch (schema.type) {
+function synthesizeFromSchema(schema: JsonSchema): JsonValue | undefined {
+  // Draft-07 type arrays (`['string','null']`) synthesize from the
+  // first non-null member — the canonical nullability form the
+  // enforced-props-schema emission produces.
+  const declared = Array.isArray(schema.type)
+    ? schema.type.find((t) => t !== 'null')
+    : schema.type;
+  switch (declared) {
     case 'string': return 'sample';
-    case 'number': return 0;
+    case 'number':
+    case 'integer': return 0;
     case 'boolean': return false;
+    case 'null': return null;
     case 'array': {
-      const itemSchema = schema.items as { type?: string } | undefined;
-      if (itemSchema) return [synthesizeFromSchema(itemSchema) ?? null];
+      if (schema.items) return [synthesizeFromSchema(schema.items) ?? null];
       return [];
     }
     case 'object': {
       const obj: JsonObject = {};
       if (schema.properties) {
         for (const [k, v] of Object.entries(schema.properties)) {
-          obj[k] = synthesizeFromSchema(v as { type?: string });
+          obj[k] = synthesizeFromSchema(v);
         }
       }
       return obj;

package/src/validation/ui-compiler.ts

@@ -64,8 +64,8 @@ const SANDBOX_EXTERNALS = [
   '@ggui-ai/design/*',
   '@ggui-ai/wire',
   '@ggui-ai/wire/*',
-  '@ggui-ai/react',
-  '@ggui-ai/react/*',
+  '@ggui-ai/mcp-apps-react',
+  '@ggui-ai/mcp-apps-react/*',
 ];
 
 /** Max compiled bundle size (2MB). Prevents accidentally bundling huge deps. */