@soederpop/luca 0.1.2 → 0.1.3

package/CLAUDE.md

@@ -111,3 +111,5 @@ This means **JSDoc blocks on helpers (features, clients, servers) must be valid
 ## Git Strategy
 
 - We generally roll all on main.  Commit your changes after you're done, only your changes.  Leave a good message, tell me why don't just tell me what.  Don't gimme that coauthored by whoever bullshit.  The streets know we're one.
+
+- Always commit your work

package/assistants/codingAssistant/hooks.ts

@@ -1,9 +1,5 @@
 import type { Assistant } from "@/agi"
 
 export function started() {
-	assistant.state.set('startedHookRan', true)
-}
-
-export function created(assistant: Assistant) {
-	assistant.use(container.feature('skillsLibrary'))
+  assistant.use(container.feature('skillsLibrary'))
 }

package/assistants/inkbot/CORE.md

@@ -0,0 +1,69 @@
+---
+maxTokens: 4096
+skills:
+  - luca-framework
+---
+# Inkbot — Canvas Renderer
+
+You are an expert in the Luca framework running inside a split-pane terminal UI. The left pane is this chat. The right pane is a **canvas** that you control by writing TypeScript code.
+
+## How the Canvas Works
+
+You have a `draw` tool. When you call it, the code you provide runs as a **bun subprocess** and its stdout appears in the canvas panel. If the script exits with an error, you receive the stderr — fix the code and redraw.
+
+A "redraw" is just calling `draw` again with updated code. The canvas always shows the output of the most recent run of the active scene.
+
+### Scenes
+
+The canvas supports multiple named **scenes**. Each scene is a separate script. You can:
+
+- `draw` — create or update a scene and run it immediately (default scene id: `"default"`)
+- `create_scene` — stage a scene without running it
+- `run_scene` — run a specific scene
+- `run_all` — run every scene in order
+- `activate_scene` — switch which scene the canvas displays
+- `get_canvas` — inspect the current output, errors, code, and status
+
+### Writing Scene Code
+
+Scene code runs **inside the container** via `vm.run()` with the full container context injected. You have `container`, every enabled feature, and all standard globals available — no imports needed. Use `console.log()` to produce visible output in the canvas.
+
+Available in scene scope:
+- `container` — the live AGI container instance
+- All enabled features as top-level globals (e.g. `fs`, `proc`, `ui`, `grep`, etc.)
+- `fetch`, `URL`, `URLSearchParams`, `Buffer`, `process`, `setTimeout`, etc.
+
+Use your `luca_describe` tools to learn the APIs. Then write scene code that uses them directly:
+
+```ts
+// Example: list available features
+const available = container.features.available
+console.log("Available features:")
+available.forEach(f => console.log(`  - ${f}`))
+```
+
+```ts
+// Example: read and display a file
+const content = fs.readFile('package.json')
+const pkg = JSON.parse(content)
+console.log(`${pkg.name} v${pkg.version}`)
+console.log(`Dependencies: ${Object.keys(pkg.dependencies || {}).length}`)
+```
+
+Tips:
+- **Simple output**: `console.log("Hello world")` — plain text renders in the canvas.
+- **Formatted tables**: Build strings with padding, box-drawing characters, or ANSI escape codes.
+- **Dynamic data**: Fetch APIs, read files, compute values — full container power.
+- **Async**: Top-level `await` works. Fetch URLs, run queries, whatever you need.
+
+### Error Recovery
+
+If your code has a bug, you will receive the error output. Read the error carefully, fix the issue, and call `draw` again. Do not apologize excessively — just fix it and redraw. The user expects iteration.
+
+## Your Personality
+
+You are creative, concise, and action-oriented. When the user asks you to render something, do it immediately — show, don't tell. Keep chat responses brief; let the canvas speak. When explaining what you drew, be specific about what's visible.
+
+## Your Tools
+
+In addition to the canvas tools above, you have access to Luca framework inspection tools (`luca_describe`, etc.) through the skills library. Use them to look up features, APIs, and helpers when writing scene code.

package/assistants/inkbot/hooks.ts

@@ -0,0 +1,14 @@
+import type { AGIContainer, Assistant } from "@soederpop/luca/agi"
+
+declare global {
+	var assistant: Assistant
+	var container: AGIContainer
+}
+
+export function started() {
+	assistant
+		// this will give it the ability to read documentation from the various feature
+		.use(container.describer)
+		// use the documentation from the various available skils
+		.use(container.feature('skillsLibrary'))
+}

package/assistants/inkbot/tools.ts

@@ -0,0 +1,47 @@
+import container from '@soederpop/luca/agi'
+import { z } from 'zod'
+
+export const schemas = {
+	README: z.object({}).describe('Call this tool first to learn how your canvas tools work.')
+}
+
+export function README() {
+	return README_CONTENT
+}
+
+const README_CONTENT = `
+# Inkbot Canvas Tools
+
+You have the following tools registered on you for controlling the canvas:
+
+## draw
+Write TypeScript code that runs as a bun subprocess. stdout appears in the canvas.
+- \`code\`: string — the TypeScript to execute
+- \`sceneId\`: string (optional) — defaults to "default"
+
+## create_scene
+Create a named scene without running it.
+- \`id\`: string — unique scene name
+- \`code\`: string — TypeScript code
+
+## run_scene
+Run an existing scene by id.
+- \`id\`: string
+
+## run_all
+Run every scene in order. Returns array of results.
+
+## activate_scene
+Switch the canvas to display a different scene.
+- \`id\`: string
+
+## get_canvas
+Returns the current canvas state: output, error, code, status, and scene list.
+
+## Tips
+- Use console.log() for output — that is what renders in the canvas.
+- If your code errors, you get stderr back. Fix it and draw again.
+- You can use ANSI escape codes for colors and formatting.
+- Scenes persist — update them with draw using the same sceneId.
+- You also have luca framework inspection tools (luca_describe, etc.) to look up APIs.
+`

package/commands/inkbot.ts

@@ -0,0 +1,353 @@
+import { z } from 'zod'
+import { commands, CommandOptionsSchema } from '@soederpop/luca'
+import type { ContainerContext } from '@soederpop/luca'
+import { AGIContainer } from '../src/agi/container.server.js'
+import { tmpdir } from 'os'
+
+export const argsSchema = CommandOptionsSchema.extend({
+  model: z.string().optional().describe('OpenAI model to use'),
+})
+
+export async function inkbot(options: z.infer<typeof argsSchema>, context: ContainerContext) {
+  const container = new AGIContainer()
+
+  // ─── Load Ink ────────────────────────────────────────────────────────
+  const ink = container.feature('ink', { enable: true, patchConsole: true })
+  await ink.loadModules()
+  const React = ink.React
+  const h = React.createElement
+  const { Box, Text } = ink.components
+  const { useInput, useApp, useStdout } = ink.hooks
+  const { useState, useEffect } = React
+
+  // ─── Scene Runner ────────────────────────────────────────────────────
+  // Scenes are code strings run as bun subprocesses.
+  // The stage entity tracks which scenes exist and which is active.
+  // Scene entities track individual code, output, error, status.
+
+  const stage = container.entity('inkbot:stage')
+  stage.setState({ activeSceneId: null, sceneIds: [] as string[], tick: 0 })
+
+  const sceneMap: Record<string, ReturnType<typeof container.entity>> = {}
+
+  function bumpStage() {
+    stage.setState({ tick: ((stage.state.get('tick') as number) || 0) + 1 })
+  }
+
+  function getOrCreateScene(id: string, code: string) {
+    if (sceneMap[id]) {
+      sceneMap[id].setState({ code })
+      return sceneMap[id]
+    }
+    const scene = container.entity(`inkbot:scene:${id}`)
+    scene.setState({ code, output: '', error: '', status: 'idle', exitCode: null })
+    sceneMap[id] = scene
+    const ids = [...((stage.state.get('sceneIds') || []) as string[])]
+    if (!ids.includes(id)) ids.push(id)
+    stage.setState({ sceneIds: ids })
+    if (!stage.state.get('activeSceneId')) stage.setState({ activeSceneId: id })
+    return scene
+  }
+
+  const proc = container.feature('proc')
+  const fs = container.feature('fs')
+  const sceneTmpDir = `${tmpdir()}/inkbot-scenes`
+  fs.ensureFolder(sceneTmpDir)
+
+  async function runScene(id: string): Promise<{ output: string; error: string; exitCode: number }> {
+    const scene = sceneMap[id]
+    if (!scene) throw new Error(`Scene "${id}" not found`)
+
+    const code = scene.state.get('code') as string
+    scene.setState({ status: 'running', output: '', error: '' })
+    bumpStage()
+
+    // Write to tmpdir, shell out to `luca run` — gets full container context + process isolation
+    const file = `${sceneTmpDir}/${id.replace(/[^a-zA-Z0-9-]/g, '_')}_${Date.now()}.ts`
+    fs.writeFile(file, code)
+
+    try {
+      const result = await proc.spawnAndCapture('luca', ['run', file], {
+        cwd: container.cwd,
+        onOutput(data: string) {
+          scene.setState({ output: ((scene.state.get('output') || '') as string) + data })
+          bumpStage()
+        },
+        onError(data: string) {
+          scene.setState({ error: ((scene.state.get('error') || '') as string) + data })
+          bumpStage()
+        },
+      })
+
+      const status = result.exitCode === 0 ? 'complete' : 'failed'
+      scene.setState({ status, exitCode: result.exitCode })
+      bumpStage()
+      try { fs.unlink(file) } catch {}
+
+      return {
+        output: (scene.state.get('output') || '') as string,
+        error: (scene.state.get('error') || '') as string,
+        exitCode: result.exitCode ?? 1,
+      }
+    } catch (err: any) {
+      scene.setState({ status: 'failed', error: err.message, exitCode: 1 })
+      bumpStage()
+      try { fs.unlink(file) } catch {}
+      return { output: '', error: err.message, exitCode: 1 }
+    }
+  }
+
+  // ─── Assistant ───────────────────────────────────────────────────────
+  const mgr = container.feature('assistantsManager')
+  await mgr.discover()
+  const assistant = mgr.create('inkbot', { model: options.model })
+
+  // Scene completion → inject result into conversation so the assistant sees it
+  stage.on('sceneComplete' as any, (id: string, output: string) => {
+    const msg = output.trim()
+      ? `[Scene "${id}" completed]\n${output.trim()}`
+      : `[Scene "${id}" completed with no output]`
+    assistant.conversation?.pushMessage({ role: 'developer', content: msg })
+  })
+
+  stage.on('sceneFailed' as any, (id: string, error: string) => {
+    const msg = `[Scene "${id}" failed]\n${error.trim()}`
+    assistant.conversation?.pushMessage({ role: 'developer', content: msg })
+    // Auto-ask the assistant to fix it
+    assistant.ask(msg).catch(() => {})
+  })
+
+  // Canvas tools — registered directly so they close over stage/sceneMap
+  assistant.addTool(
+    'draw',
+    async (args: { code: string; sceneId?: string }) => {
+      const id = args.sceneId || 'default'
+      getOrCreateScene(id, args.code)
+      stage.setState({ activeSceneId: id })
+      bumpStage()
+      // Fire and forget — result feeds back via stage events
+      runScene(id).then(result => {
+        if (result.exitCode === 0) {
+          stage.emit('sceneComplete' as any, id, result.output)
+        } else {
+          stage.emit('sceneFailed' as any, id, result.error)
+        }
+      })
+      return { status: 'running', sceneId: id }
+    },
+    z.object({
+      code: z.string().describe('TypeScript code to execute. Use console.log() for visible output.'),
+      sceneId: z.string().optional().describe('Scene id (defaults to "default").'),
+    }).describe('Draw or redraw the canvas. Returns immediately — output streams to the canvas. If the scene fails, you will be notified automatically.'),
+  )
+
+  assistant.addTool(
+    'create_scene',
+    async (args: { id: string; code: string }) => {
+      getOrCreateScene(args.id, args.code)
+      return { created: args.id, allScenes: stage.state.get('sceneIds') }
+    },
+    z.object({
+      id: z.string().describe('Unique scene identifier'),
+      code: z.string().describe('TypeScript code for this scene'),
+    }).describe('Create a named scene without running it yet.'),
+  )
+
+  assistant.addTool(
+    'run_scene',
+    async (args: { id: string }) => runScene(args.id),
+    z.object({
+      id: z.string().describe('Scene id to run'),
+    }).describe('Run a specific scene by its id.'),
+  )
+
+  assistant.addTool(
+    'run_all',
+    async () => {
+      const ids = (stage.state.get('sceneIds') || []) as string[]
+      const results: any[] = []
+      for (const id of ids) results.push({ id, ...(await runScene(id)) })
+      return results
+    },
+    z.object({}).describe('Run every scene in order and return all results.'),
+  )
+
+  assistant.addTool(
+    'get_canvas',
+    async () => {
+      const activeId = stage.state.get('activeSceneId') as string | null
+      if (!activeId || !sceneMap[activeId]) return { status: 'empty', allScenes: [] }
+      const s = sceneMap[activeId]
+      return {
+        sceneId: activeId,
+        status: s.state.get('status'),
+        output: s.state.get('output'),
+        error: s.state.get('error'),
+        code: s.state.get('code'),
+        allScenes: stage.state.get('sceneIds'),
+      }
+    },
+    z.object({}).describe('Inspect the current canvas: active scene output, error, code, status.'),
+  )
+
+  assistant.addTool(
+    'activate_scene',
+    async (args: { id: string }) => {
+      if (!sceneMap[args.id]) return { error: `Scene "${args.id}" not found` }
+      stage.setState({ activeSceneId: args.id })
+      bumpStage()
+      return { activeSceneId: args.id }
+    },
+    z.object({
+      id: z.string().describe('Scene id to make active in the canvas'),
+    }).describe('Switch the canvas to display a different scene.'),
+  )
+
+  // ─── Ink App ─────────────────────────────────────────────────────────
+
+  type Msg = { role: 'user' | 'assistant' | 'system'; content: string }
+
+  function App() {
+    const [messages, setMessages] = useState<Msg[]>([])
+    const [input, setInput] = useState('')
+    const [streaming, setStreaming] = useState('')
+    const [thinking, setThinking] = useState(false)
+    const [activity, setActivity] = useState('')
+    const [canvas, setCanvas] = useState({ output: '', error: '', status: 'empty' })
+    const { exit } = useApp()
+    const { stdout } = useStdout()
+    const rows = stdout?.rows ?? 24
+
+    // --- assistant events ---
+    useEffect(() => {
+      const onPreview = (text: string) => setStreaming(text)
+      const onResponse = (text: string) => {
+        setStreaming('')
+        setThinking(false)
+        setActivity('')
+        setMessages(prev => [...prev, { role: 'assistant', content: text }])
+      }
+      const onToolCall = (name: string) => setActivity(`${name}`)
+      const onToolResult = () => setActivity('')
+
+      assistant.on('preview', onPreview)
+      assistant.on('response', onResponse)
+      assistant.on('toolCall', onToolCall)
+      assistant.on('toolResult', onToolResult)
+      return () => {
+        assistant.off('preview', onPreview)
+        assistant.off('response', onResponse)
+        assistant.off('toolCall', onToolCall)
+        assistant.off('toolResult', onToolResult)
+      }
+    }, [])
+
+    // --- stage entity ticks → canvas state ---
+    useEffect(() => {
+      const unsub = stage.state.observe((_changeType: any, key: any) => {
+        if (key !== 'tick') return
+        const activeId = stage.state.get('activeSceneId') as string | null
+        if (!activeId || !sceneMap[activeId]) {
+          setCanvas({ output: '', error: '', status: 'empty' })
+          return
+        }
+        const s = sceneMap[activeId]
+        setCanvas({
+          output: (s.state.get('output') || '') as string,
+          error: (s.state.get('error') || '') as string,
+          status: (s.state.get('status') || 'idle') as string,
+        })
+      })
+      return unsub
+    }, [])
+
+    // --- keyboard ---
+    useInput((ch, key) => {
+      if (key.escape) { exit(); return }
+
+      if (key.return) {
+        if (thinking) return
+        const msg = input.trim()
+        if (!msg) return
+        setInput('')
+        setMessages(prev => [...prev, { role: 'user', content: msg }])
+        setThinking(true)
+        assistant.ask(msg).catch((err: any) => {
+          setMessages(prev => [...prev, { role: 'system', content: `error: ${err.message}` }])
+          setThinking(false)
+        })
+        return
+      }
+
+      if (key.backspace || key.delete) {
+        setInput(prev => prev.slice(0, -1))
+        return
+      }
+
+      if (ch && !key.ctrl && !key.meta) {
+        setInput(prev => prev + ch)
+      }
+    })
+
+    // --- render ---
+    const visible = messages.slice(-30)
+    const sceneIds = (stage.state.get('sceneIds') || []) as string[]
+    const activeId = (stage.state.get('activeSceneId') || '') as string
+
+    const chatChildren: any[] = []
+
+    visible.forEach((m, i) => {
+      const color = m.role === 'user' ? 'green' : m.role === 'system' ? 'red' : 'white'
+      const prefix = m.role === 'user' ? '> ' : '  '
+      chatChildren.push(h(Text, { key: `msg-${i}`, wrap: 'wrap', color }, `${prefix}${m.content}`))
+    })
+
+    if (streaming) chatChildren.push(h(Text, { key: 'chat-stream', wrap: 'wrap', dimColor: true }, `  ${streaming}`))
+    if (thinking && !streaming) chatChildren.push(h(Text, { key: 'chat-think', color: 'yellow' }, '  thinking...'))
+    if (activity) chatChildren.push(h(Text, { key: 'chat-act', color: 'blue' }, `  [${activity}]`))
+
+    const canvasBody = canvas.output
+      ? h(Text, { key: 'cvs-out', wrap: 'wrap' }, canvas.output)
+      : canvas.status === 'empty'
+        ? h(Text, { key: 'cvs-empty', dimColor: true }, '  ask inkbot to draw something')
+        : null
+
+    // border + header + status = 4 rows overhead per panel
+    const panelHeight = rows - 2
+
+    return h(Box, { flexDirection: 'row', width: '100%', height: rows },
+      // ── Chat ──
+      h(Box, { key: 'chat', flexDirection: 'column', width: '50%', height: rows, borderStyle: 'round', borderColor: 'cyan', paddingX: 1 },
+        h(Text, { bold: true, color: 'cyan' }, ' inkbot '),
+        h(Box, { flexDirection: 'column', flexGrow: 1, overflow: 'hidden' }, ...chatChildren),
+        h(Box, { borderStyle: 'single', borderColor: 'gray', paddingX: 1 },
+          h(Text, { color: 'green' }, '> '),
+          h(Text, null, input),
+          h(Text, { dimColor: true }, '\u2588'),
+        ),
+      ),
+      // ── Canvas ──
+      h(Box, { key: 'canvas', flexDirection: 'column', width: '50%', height: rows, borderStyle: 'round', borderColor: 'magenta', paddingX: 1 },
+        h(Text, { bold: true, color: 'magenta' }, ' canvas '),
+        h(Box, { flexDirection: 'column', height: panelHeight - 4, overflow: 'hidden' },
+          canvasBody,
+          canvas.error ? h(Text, { key: 'cvs-err', color: 'red', wrap: 'wrap' }, canvas.error) : null,
+        ),
+        h(Box, null,
+          h(Text, { dimColor: true }, ` ${canvas.status}`),
+          sceneIds.length > 1 ? h(Text, { dimColor: true }, `  scenes: ${sceneIds.join(', ')}  active: ${activeId}`) : null,
+        ),
+      ),
+    )
+  }
+
+  // Mount and hold
+  await ink.render(h(App))
+  await ink.waitUntilExit()
+}
+
+export default {
+  description: 'Launch the Inkbot split-pane assistant with a live canvas.',
+  argsSchema,
+  handler: inkbot,
+}

package/dist/agi/container.server.d.ts

@@ -0,0 +1,63 @@
+import type { ContainerState } from '../container';
+import { type NodeFeatures, NodeContainer } from '../node/container';
+import '@/introspection/generated.agi.js';
+import { OpenAIClient } from '../clients/openai';
+import { ElevenLabsClient } from '../clients/elevenlabs';
+import { ClaudeCode } from './features/claude-code';
+import { OpenAICodex } from './features/openai-codex';
+import { Conversation } from './features/conversation';
+import { ConversationHistory } from './features/conversation-history';
+import { Assistant } from './features/assistant';
+import { AssistantsManager } from './features/assistants-manager';
+import { DocsReader } from './features/docs-reader';
+import { SkillsLibrary } from './features/skills-library';
+import { BrowserUse } from './features/browser-use';
+import { SemanticSearch } from '@soederpop/luca/node/features/semantic-search';
+import { ContentDb } from '@soederpop/luca/node/features/content-db';
+import { FileTools } from './features/file-tools';
+import { LucaCoder } from './features/luca-coder';
+import type { ConversationTool } from './features/conversation';
+import type { ZodType } from 'zod';
+export { ClaudeCode, OpenAICodex, Conversation, ConversationHistory, Assistant, AssistantsManager, DocsReader, SkillsLibrary, BrowserUse, FileTools, LucaCoder, SemanticSearch, ContentDb, NodeContainer, OpenAIClient, ElevenLabsClient, };
+export type { ConversationTool, ZodType, ContainerState, NodeFeatures, };
+export interface AGIFeatures extends NodeFeatures {
+    conversation: typeof Conversation;
+    claudeCode: typeof ClaudeCode;
+    openaiCodex: typeof OpenAICodex;
+    conversationHistory: typeof ConversationHistory;
+    assistant: typeof Assistant;
+    assistantsManager: typeof AssistantsManager;
+    docsReader: typeof DocsReader;
+    skillsLibrary: typeof SkillsLibrary;
+    browserUse: typeof BrowserUse;
+    fileTools: typeof FileTools;
+    lucaCoder: typeof LucaCoder;
+}
+export interface ConversationFactoryOptions {
+    tools?: {
+        handlers: Record<string, ConversationTool['handler']>;
+        schemas: Record<string, ZodType>;
+    };
+    systemPrompt?: string;
+    model?: string;
+    id?: string;
+    title?: string;
+    thread?: string;
+    tags?: string[];
+    metadata?: Record<string, any>;
+}
+/**
+ * AGI-specific container that extends NodeContainer with AI capabilities including
+ * OpenAI conversations, code generation, and self-modifying agent features.
+ */
+export declare class AGIContainer<Features extends AGIFeatures = AGIFeatures, K extends ContainerState = ContainerState> extends NodeContainer<Features, K> {
+    openai: OpenAIClient;
+    claudeCode?: ClaudeCode;
+    openaiCodex?: OpenAICodex;
+    conversationHistory?: ConversationHistory;
+    docs: ContentDb;
+    conversation(options?: ConversationFactoryOptions): Promise<InstanceType<Features["conversation"]>>;
+}
+declare const container: any;
+export default container;
+//# sourceMappingURL=container.server.d.ts.map

package/dist/agi/container.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.server.d.ts","sourceRoot":"","sources":["../../src/agi/container.server.ts"],"names":[],"mappings":"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"}

package/dist/agi/endpoints/ask.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { EndpointContext } from '../../endpoint.js';
+export declare const path = "/ask";
+export declare const description = "Ask the AGI container a question";
+export declare const tags: string[];
+export declare const postSchema: z.ZodObject<{
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    stream: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export declare function post(parameters: z.infer<typeof postSchema>, ctx: EndpointContext): Promise<{
+    answer: any;
+} | undefined>;
+export declare const getSchema: z.ZodObject<{
+    question: z.ZodString;
+}, z.core.$strip>;
+export declare function get(parameters: z.infer<typeof getSchema>, ctx: EndpointContext): Promise<{
+    answer: any;
+}>;
+//# sourceMappingURL=ask.d.ts.map

package/dist/agi/endpoints/ask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../../src/agi/endpoints/ask.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,eAAO,MAAM,IAAI,SAAS,CAAA;AAC1B,eAAO,MAAM,WAAW,qCAAqC,CAAA;AAC7D,eAAO,MAAM,IAAI,UAAU,CAAA;AAE3B,eAAO,MAAM,UAAU;;;;iBAIrB,CAAA;AAEF,wBAAsB,IAAI,CACxB,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,EACtC,GAAG,EAAE,eAAe;;eA+BrB;AAED,eAAO,MAAM,SAAS;;iBAEpB,CAAA;AAEF,wBAAsB,GAAG,CACvB,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,EACrC,GAAG,EAAE,eAAe;;GAKrB"}

package/dist/agi/endpoints/conversations/[id].d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import type { EndpointContext } from '../../../endpoint.js';
+export declare const path = "/api/conversations/:id";
+export declare const description = "Get or delete a specific conversation";
+export declare const tags: string[];
+export declare const getSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare function get(parameters: z.infer<typeof getSchema>, ctx: EndpointContext): Promise<{
+    error: string;
+    conversation?: undefined;
+} | {
+    conversation: any;
+    error?: undefined;
+}>;
+export declare const deleteSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export declare function del(parameters: z.infer<typeof deleteSchema>, ctx: EndpointContext): Promise<{
+    error: string;
+    deleted?: undefined;
+} | {
+    deleted: boolean;
+    error?: undefined;
+}>;
+export { del as delete };
+//# sourceMappingURL=%5Bid%5D.d.ts.map

package/dist/agi/endpoints/conversations/[id].d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"[id].d.ts","sourceRoot":"","sources":["../../../../src/agi/endpoints/conversations/[id].ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAE3D,eAAO,MAAM,IAAI,2BAA2B,CAAA;AAC5C,eAAO,MAAM,WAAW,0CAA0C,CAAA;AAClE,eAAO,MAAM,IAAI,UAAoB,CAAA;AAErC,eAAO,MAAM,SAAS;;iBAEpB,CAAA;AAEF,wBAAsB,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,EAAE,GAAG,EAAE,eAAe;;;;;;GAYpF;AAED,eAAO,MAAM,YAAY;;iBAEvB,CAAA;AAEF,wBAAsB,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,GAAG,EAAE,eAAe;;;;;;GAYvF;AAGD,OAAO,EAAE,GAAG,IAAI,MAAM,EAAE,CAAA"}

package/dist/agi/endpoints/conversations.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import type { EndpointContext } from '../../endpoint.js';
+export declare const path = "/api/conversations";
+export declare const description = "List and search saved conversations";
+export declare const tags: string[];
+export declare const getSchema: z.ZodObject<{
+    tag: z.ZodOptional<z.ZodString>;
+    thread: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    expert: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+}, z.core.$strip>;
+export declare function get(parameters: z.infer<typeof getSchema>, ctx: EndpointContext): Promise<{
+    conversations: any;
+}>;
+//# sourceMappingURL=conversations.d.ts.map

package/dist/agi/endpoints/conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversations.d.ts","sourceRoot":"","sources":["../../../src/agi/endpoints/conversations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,eAAO,MAAM,IAAI,uBAAuB,CAAA;AACxC,eAAO,MAAM,WAAW,wCAAwC,CAAA;AAChE,eAAO,MAAM,IAAI,UAAoB,CAAA;AAErC,eAAO,MAAM,SAAS;;;;;;;;iBAQpB,CAAA;AAEF,wBAAsB,GAAG,CAAC,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,EAAE,GAAG,EAAE,eAAe;;GAapF"}

package/dist/agi/endpoints/experts.d.ts

@@ -0,0 +1,8 @@
+import type { EndpointContext } from '../../endpoint.js';
+export declare const path = "/api/experts";
+export declare const description = "List all available experts with their descriptions";
+export declare const tags: string[];
+export declare function get(_parameters: any, ctx: EndpointContext): Promise<{
+    experts: any[];
+}>;
+//# sourceMappingURL=experts.d.ts.map

package/dist/agi/endpoints/experts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experts.d.ts","sourceRoot":"","sources":["../../../src/agi/endpoints/experts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD,eAAO,MAAM,IAAI,iBAAiB,CAAA;AAClC,eAAO,MAAM,WAAW,uDAAuD,CAAA;AAC/E,eAAO,MAAM,IAAI,UAAc,CAAA;AAE/B,wBAAsB,GAAG,CAAC,WAAW,EAAE,GAAG,EAAE,GAAG,EAAE,eAAe;;GA6B/D"}