@tangle-network/starter-foundry 0.7.2 → 0.13.0

package/registry/families/agent-runtime-wealth-manager-ts/manifest.json

@@ -0,0 +1,194 @@
+{
+  "id": "agent-runtime-wealth-manager-ts",
+  "description": "Personal wealth-manager agent bundle \u2014 peer-style information on asset allocation, tax-loss harvesting, and retirement projection. Explicitly NOT a registered investment adviser, NOT a fiduciary, NOT licensed financial advice. Demonstrates the agent-runtime substrate composing on a regulated-finance role with structured-output blocks (:::artifact, :::escalation) and a hard refusal contract for actionable trade picks.",
+  "tags": [
+    "agent-runtime",
+    "personal-finance",
+    "wealth-management",
+    "regulated-finance",
+    "cloudflare-worker"
+  ],
+  "taxonomy": {
+    "language": "markdown",
+    "runtime": "cloudflare-worker",
+    "surface": "agent-runtime"
+  },
+  "includes": [
+    "agent-base:tangle",
+    "agent-base:secure",
+    "agent-base:privacy",
+    "agent-output:blocks",
+    "agent-base:memory",
+    "agent-base:scheduler",
+    "agent-base:mcp-registry",
+    "agent-channels:telegram",
+    "agent-channels:discord",
+    "agent-channels:slack",
+    "agent-channels:whatsapp",
+    "agent-channels:imessage",
+    "agent-channels:gmail",
+    "agent-channels:linear"
+  ],
+  "defaults": {
+    "projectType": "agent-runtime-wealth-manager",
+    "agentName": "wealth-manager",
+    "publicVars": [
+      "AGENT_NAME"
+    ],
+    "routes": [
+      {
+        "path": "/api/chat",
+        "auth": "bearer",
+        "callsTools": [
+          "allocation-review",
+          "tax-lot-scan",
+          "projection"
+        ]
+      },
+      {
+        "path": "/api/health",
+        "auth": "none",
+        "callsTools": []
+      }
+    ],
+    "declaredCapabilities": [
+      "asset-allocation-review",
+      "tax-loss-harvesting",
+      "retirement-projection",
+      "regulatory-disclaimer"
+    ],
+    "runtime": {
+      "sandbox": "tangle",
+      "noNewPrivileges": true,
+      "capDrop": "ALL"
+    },
+    "disclaimerRequired": true,
+    "notFiduciary": true,
+    "regulatoryDisclaimer": true,
+    "schedule": [
+      {
+        "id": "scheduled-1",
+        "cron": "0 14 1 * *",
+        "capability": "asset-allocation-review"
+      }
+    ],
+    "outboundDomains": [
+      "api.tangle.tools",
+      "sec.gov",
+      "irs.gov"
+    ],
+    "secrets": [
+      "TANGLE_API_KEY"
+    ]
+  },
+  "files": [
+    {
+      "source": "files/agent.json",
+      "target": "agent.json"
+    },
+    {
+      "source": "files/AGENTS.md",
+      "target": "AGENTS.md"
+    },
+    {
+      "source": "files/methodology/index.json",
+      "target": "methodology/index.json"
+    },
+    {
+      "source": "files/methodology/allocation-review.md",
+      "target": "methodology/allocation-review.md"
+    },
+    {
+      "source": "files/methodology/tax-loss-harvest-protocol.md",
+      "target": "methodology/tax-loss-harvest-protocol.md"
+    },
+    {
+      "source": "files/methodology/retirement-projection.md",
+      "target": "methodology/retirement-projection.md"
+    },
+    {
+      "source": "files/README.md",
+      "target": "README.md"
+    },
+    {
+      "source": "files/TOOLS.md",
+      "target": "TOOLS.md"
+    }
+  ],
+  "validationChecks": [
+    {
+      "type": "file-exists",
+      "path": "AGENTS.md"
+    },
+    {
+      "type": "file-exists",
+      "path": "methodology/index.json"
+    },
+    {
+      "type": "agents-md-valid",
+      "path": "AGENTS.md"
+    },
+    {
+      "type": "methodology-index-valid",
+      "path": "methodology/index.json"
+    },
+    {
+      "type": "schedule-valid",
+      "path": "manifest.json"
+    },
+    {
+      "type": "file-exists",
+      "path": "TOOLS.md"
+    }
+  ],
+  "contextHints": {
+    "commands": [],
+    "entrypoints": [
+      "AGENTS.md"
+    ],
+    "extensionPoints": [
+      "templates/",
+      "src/lib/tools/"
+    ]
+  },
+  "keywords": [
+    "wealth",
+    "investing",
+    "asset-allocation",
+    "tax-loss-harvesting",
+    "retirement",
+    "rebalancing"
+  ],
+  "tieredKeywords": {
+    "tier1": [
+      "wealth-manager",
+      "wealth manager",
+      "financial-planner-agent",
+      "financial planner",
+      "personal-cfo",
+      "personal cfo",
+      "personal wealth"
+    ],
+    "tier2": [
+      "asset-allocation",
+      "asset allocation",
+      "tax-loss-harvesting",
+      "tax loss harvesting",
+      "retirement-planning",
+      "retirement planning",
+      "estate",
+      "529"
+    ],
+    "tier3": [
+      "investing",
+      "portfolio",
+      "rebalancing",
+      "ira"
+    ],
+    "archetypes": [
+      "agent-in-sandbox",
+      "advisory-agent",
+      "regulated-finance"
+    ]
+  }
+}

package/registry/families/agent-service-ts/files/package.json

@@ -11,6 +11,8 @@
   "pnpm": {
     "overrides": {
       "vite": "^6.4.2"
-    }
+    },
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/families/agent-swarm-ts/files/package.json

@@ -26,6 +26,8 @@
   "pnpm": {
     "overrides": {
       "vite": "^6.4.2"
-    }
+    },
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
   }
 }

package/registry/families/agent-swarm-ts/manifest.json

@@ -140,7 +140,7 @@
   "buildHints": {
     "whenToUse": "Multi-agent orchestration with supervisor/worker handoffs. Use when ONE LLM call isn't enough \u2014 research agents that delegate to search/analyze/summarize roles, triage+specialist support, document pipelines. For a single agent with tool use, use `agent-service-ts` instead.",
     "firstSteps": [
-      "Set the router API key: `export OPENAI_API_KEY=$TANGLE_ROUTER_KEY` \u2014 agents call via router.tangle.tools, NOT OpenAI directly.",
+      "Set the router API key: `export OPENAI_API_KEY=$TANGLE_API_KEY` \u2014 agents call via router.tangle.tools, NOT OpenAI directly.",
       "Add a new specialist: create `src/agents/<name>.ts` exporting a `run<Name>(state)` function. Register it in supervisor.ts's node graph.",
       "Extend `SwarmState` in src/state.ts when adding fields the new agent reads/writes. Use the Annotation<T>({ reducer }) pattern \u2014 reducers determine how updates merge.",
       "The supervisor is rule-based (src/supervisor.ts). Swap to an LLM-driven supervisor by replacing `supervise()` with an LLM call if the routing is non-obvious.",

package/registry/families/agent-with-ui-ts/files/README.md

@@ -0,0 +1,107 @@
+# {{agentName}} — agent-with-ui-ts
+
+A React + Vite + TypeScript scaffold for a **single-agent UI**: an operator-facing
+chat surface plus artifact pane that talks to one `agent-runtime-*` bundle running
+in a Tangle sandbox.
+
+This bundle is the "single agent with UI" archetype. It composes:
+
+- `@tangle-network/sandbox-ui` — `SandboxWorkbench` layout, `ChatContainer`,
+  `useSdkSession` event reducer.
+- `@tangle-network/sandbox` — your transport to the sandbox running the
+  agent-runtime bundle.
+- `ui-adapter:blocks-renderer` (auto-composed) — parses `:::artifact`,
+  `:::escalation`, `:::screener-result`, `:::audio-cue`, `:::suggestion`,
+  `:::proposal`, `:::filing`, `:::survey` fenced blocks out of agent text and
+  maps them onto `SandboxWorkbenchArtifact[]` for the artifact pane.
+
+## Compose with an agent-runtime bundle
+
+This UI is bundle-agnostic. Pair it with any of the existing agent-runtime
+families to ship a complete product:
+
+| Pair | Result |
+| --- | --- |
+| `agent-with-ui-ts` + `agent-runtime-cmo-advisor-ts` | CMO advisor with chat UI |
+| `agent-with-ui-ts` + `agent-runtime-tax-ts` | Tax assistant with filing artifacts |
+| `agent-with-ui-ts` + `agent-runtime-therapist-ts` | Therapy companion with screener-result pane |
+| `agent-with-ui-ts` + `agent-runtime-research` | Research agent with artifact pane |
+
+Eight agent-runtime bundles ship today — `business-partner`, `cmo-advisor`,
+`fitness-coach`, `language-tutor`, `legal-counsel`, `music-producer`,
+`novelist-coach`, `real-estate`, `recruiter`, `research`, `tax`, `therapist`,
+`wealth-manager`. Pick one, deploy its worker, then point this UI at it via
+the invoker seam below.
+
+## How the `:::output-block` parser works
+
+Whenever the agent emits text containing fenced blocks like:
+
+```
+:::artifact title="Q3 Positioning Canvas"
+# Positioning
+...
+:::
+```
+
+the scaffold parses it (via `src/lib/parse-blocks.ts`) and maps it onto a
+`SandboxWorkbenchArtifact` (via `src/lib/blocks-to-artifacts.tsx`), which the
+workbench renders in its artifact pane automatically. No per-bundle UI glue.
+
+The adapter is rebuilt on every assistant part update, so the artifact pane
+streams in tandem with the chat surface.
+
+## Required env vars
+
+```bash
+VITE_AGENT_NAME='{{agentName}}'              # display name in the title bar
+VITE_SANDBOX_API_URL='{{sandboxApiUrl}}'     # tangle sandbox API root
+VITE_SANDBOX_API_TOKEN='sk-tan-...'          # operator key, scoped to this agent's product
+```
+
+## Wiring the agent invoker (the one piece you write)
+
+`App.tsx` accepts an `invoker: AgentInvoker` prop. The scaffold itself ships
+no transport — you wire it once based on which agent-runtime bundle you're
+driving. Minimum implementation against `@tangle-network/sandbox`:
+
+```tsx
+// src/main.tsx
+import { connectSandbox } from '@tangle-network/sandbox'
+
+const sandbox = await connectSandbox({
+  baseUrl: import.meta.env.VITE_SANDBOX_API_URL!,
+  token: import.meta.env.VITE_SANDBOX_API_TOKEN!,
+})
+
+const invoker = {
+  async invoke({ userText, onEvent, signal }) {
+    // TODO: replace with the exact sandbox-sdk method exposed by your
+    // agent-runtime bundle's worker. For the canonical agent-runtime
+    // shape (POST /api/chat returning an SSE stream of SdkSessionEvent),
+    // call `sandbox.session.stream({ message: userText, signal })` and
+    // forward each event into `onEvent`.
+    for await (const event of sandbox.session.stream({ message: userText, signal })) {
+      onEvent(event)
+    }
+  },
+}
+
+createRoot(container).render(<App invoker={invoker} />)
+```
+
+## Extension points
+
+- `src/App.tsx` — layout, header, status surface, invoker prop.
+- `src/lib/blocks-to-artifacts.tsx` — `registerBlockMapper(kind, mapper)` to
+  add bundle-specific block kinds (e.g. `:::positioning-canvas`) without
+  forking the layer.
+
+## What's NOT in scope
+
+- **Multi-agent dashboard** (running several agents side-by-side, routing
+  between them, shared artifact streams) → use `orchestrator-with-ui-ts`.
+- **Non-agent workspace** (file editor, terminal-only, no chat surface) →
+  use `sandbox-app-ts`.
+- **The agent-runtime worker itself** — that's a separate bundle. This scaffold
+  only ships the operator-facing UI.

package/registry/families/agent-with-ui-ts/files/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang='en'>
+  <head>
+    <meta charset='UTF-8' />
+    <meta name='viewport' content='width=device-width, initial-scale=1.0' />
+    <title>{{agentName}} — Sandbox UI</title>
+  </head>
+  <body>
+    <div id='root'></div>
+    <script type='module' src='/src/main.tsx'></script>
+  </body>
+</html>

package/registry/families/agent-with-ui-ts/files/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "{{projectName}}",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tangle-network/sandbox-ui": "^0.10.3",
+    "@tangle-network/sandbox": "^0.2.1",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.0",
+    "@types/react-dom": "^18.3.0",
+    "@vitejs/plugin-react": "^4.7.0",
+    "autoprefixer": "^10.4.20",
+    "postcss": "^8.4.47",
+    "tailwindcss": "^3.4.13",
+    "typescript": "^5.9.0",
+    "vite": "^6.4.2"
+  },
+  "pnpm": {
+    "minimumReleaseAge": 4320,
+    "minimumReleaseAgeExclude": []
+  }
+}

package/registry/families/agent-with-ui-ts/files/postcss.config.cjs

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

package/registry/families/agent-with-ui-ts/files/src/App.tsx

@@ -0,0 +1,147 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useSdkSession, type SdkSessionEvent } from '@tangle-network/sandbox-ui/hooks'
+import {
+  SandboxWorkbench,
+  type SandboxWorkbenchArtifact,
+} from '@tangle-network/sandbox-ui/workspace'
+import type { TextPart } from '@tangle-network/sandbox-ui/types'
+import {
+  makeArtifactStreamAdapter,
+} from './lib/blocks-to-artifacts'
+
+// AgentInvoker is the seam between this UI scaffold and whichever
+// agent-runtime bundle the operator is driving. The scaffold has zero
+// per-bundle knowledge — the operator wires the actual transport
+// (sandbox-sdk client, fetch to /api/chat, websocket, etc.) here.
+//
+// Contract: invoke is given the full message history + the new user text;
+// it must stream `SdkSessionEvent`s back via onEvent until the run is done.
+// Returning ends the streaming state.
+export interface AgentInvoker {
+  invoke: (args: {
+    userText: string
+    onEvent: (event: SdkSessionEvent) => void
+    signal: AbortSignal
+  }) => Promise<void>
+}
+
+export interface AppProps {
+  agentName?: string
+  invoker?: AgentInvoker
+}
+
+const ENV_AGENT_NAME =
+  (import.meta.env.VITE_AGENT_NAME as string | undefined) ?? '{{agentName}}'
+
+export function App({ agentName = ENV_AGENT_NAME, invoker }: AppProps = {}) {
+  const {
+    messages,
+    partMap,
+    isStreaming,
+    activeAssistantMessageId,
+    appendUserMessage,
+    beginAssistantMessage,
+    applySdkEvent,
+    failAssistantMessage,
+  } = useSdkSession()
+
+  const [activeArtifactId, setActiveArtifactId] = useState<string | undefined>()
+  const adapter = useMemo(() => makeArtifactStreamAdapter(), [])
+  const [artifacts, setArtifacts] = useState<SandboxWorkbenchArtifact[]>([])
+  const abortRef = useRef<AbortController | null>(null)
+
+  // Re-parse the active assistant message text on every part update and
+  // hand the rebuilt SandboxWorkbenchArtifact[] to the workbench. The
+  // adapter is idempotent on identical text so this is cheap.
+  useEffect(() => {
+    if (!activeAssistantMessageId) return
+    const parts = partMap[activeAssistantMessageId] ?? []
+    const assistantText = parts
+      .filter((p): p is TextPart => p.type === 'text')
+      .map((p) => p.text)
+      .join('\n')
+    const next = adapter.feed(assistantText)
+    setArtifacts(next)
+    if (next.length > 0 && !activeArtifactId) {
+      setActiveArtifactId(next[0]!.id)
+    }
+  }, [activeAssistantMessageId, partMap, adapter, activeArtifactId])
+
+  // Also re-feed on completed assistant messages so the artifact pane
+  // keeps the final state once streaming ends. Walks history newest-first
+  // and grabs the first assistant message with text.
+  useEffect(() => {
+    if (activeAssistantMessageId || isStreaming) return
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = messages[i]!
+      if (m.role !== 'assistant') continue
+      const parts = partMap[m.id] ?? []
+      const text = parts
+        .filter((p): p is TextPart => p.type === 'text')
+        .map((p) => p.text)
+        .join('\n')
+      if (!text) continue
+      const next = adapter.feed(text)
+      setArtifacts(next)
+      if (next.length > 0 && !activeArtifactId) {
+        setActiveArtifactId(next[0]!.id)
+      }
+      break
+    }
+  }, [messages, partMap, isStreaming, activeAssistantMessageId, adapter, activeArtifactId])
+
+  const handleSend = useCallback(
+    async (text: string) => {
+      const trimmed = text.trim()
+      if (!trimmed) return
+      appendUserMessage({ content: trimmed })
+      const assistantId = beginAssistantMessage()
+
+      // No invoker wired? Surface a helpful failure rather than a silent
+      // stuck-streaming spinner.
+      if (!invoker) {
+        failAssistantMessage(
+          'No agent invoker wired. See README — pass an `invoker` prop that ' +
+            'streams SdkSessionEvents from your sandbox-sdk client.',
+          { messageId: assistantId },
+        )
+        return
+      }
+
+      abortRef.current?.abort()
+      const ac = new AbortController()
+      abortRef.current = ac
+
+      try {
+        await invoker.invoke({
+          userText: trimmed,
+          signal: ac.signal,
+          onEvent: (event) => applySdkEvent(event, { messageId: assistantId }),
+        })
+      } catch (err) {
+        if (ac.signal.aborted) return
+        const reason = err instanceof Error ? err.message : String(err)
+        failAssistantMessage(reason, { messageId: assistantId })
+      }
+    },
+    [appendUserMessage, beginAssistantMessage, applySdkEvent, failAssistantMessage, invoker],
+  )
+
+  useEffect(() => () => abortRef.current?.abort(), [])
+
+  return (
+    <SandboxWorkbench
+      title={agentName}
+      subtitle='Single-agent runtime — chat + artifact pane'
+      session={{
+        messages,
+        partMap,
+        isStreaming,
+        onSend: handleSend,
+      }}
+      artifacts={artifacts}
+      activeArtifactId={activeArtifactId}
+      onArtifactChange={setActiveArtifactId}
+    />
+  )
+}

package/registry/families/agent-with-ui-ts/files/src/index.css

@@ -0,0 +1,12 @@
+@import '@tangle-network/sandbox-ui/styles';
+
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+html,
+body,
+#root {
+  height: 100%;
+  margin: 0;
+}

package/registry/families/agent-with-ui-ts/files/src/main.tsx

@@ -0,0 +1,13 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import { App } from './App'
+import './index.css'
+
+const container = document.getElementById('root')
+if (!container) throw new Error('#root mount point missing from index.html')
+
+createRoot(container).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

package/registry/families/agent-with-ui-ts/files/tailwind.config.cjs

@@ -0,0 +1,8 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  content: ['./index.html', './src/**/*.{ts,tsx,html}'],
+  theme: {
+    extend: {},
+  },
+  plugins: [],
+}

package/registry/families/agent-with-ui-ts/files/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": false,
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/registry/families/agent-with-ui-ts/files/vite.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'node:path'
+
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, 'src'),
+    },
+  },
+  server: {
+    port: {{port}},
+  },
+})