@kazzle/app 0.1.944 → 0.1.946

package/dist/index.d.ts

@@ -1,105 +1 @@
-export interface KazzleComponentEnv {
-    /** Secret collection slug */
-    collection: string;
-    /** Environment slug for secret injection */
-    environment: string;
-    /** Only inject these env var names. If omitted, inject all from collection+environment. */
-    include?: string[];
-}
-export interface KazzleRuntimeMode {
-    /** Command to start the component in this mode (e.g. "bun run dev", "bun run start") */
-    command: string;
-    /** Command to build for this mode (used by production deploys, e.g. "bun run build") */
-    build?: string;
-    /** Mode-specific secret collection + environment. Falls back to the component env. */
-    env?: KazzleComponentEnv;
-}
-export interface KazzleComponentRuntime {
-    /** Local dev / preview runtime */
-    dev?: KazzleRuntimeMode;
-    /** Production runtime */
-    prod?: KazzleRuntimeMode;
-}
-/**
- * A single trigger entry on a process component. One component can declare
- * many triggers — for example, a daily cron AND a webhook handler that both
- * route into the same code.
- *
- *   - `kind: 'schedule'` → fires on the cron expression in `schedule`.
- *     `schedule` is a 5-field cron expression with minute resolution.
- *
- *   - `kind: 'webhook'`  → fires when the platform receives
- *     `POST /webhooks/{spaceId}/{appId}/{componentName}/{name}`.
- *
- * `path` is the HTTP route on the running server that handles this trigger.
- * Required when `processMode: 'persistent'` (the platform POSTs the trigger
- * into the long-running server at this path with `Authorization: Bearer
- * ${KAZZLE_TRIGGER_SECRET}`). Ignored for `processMode: 'triggered'` — those
- * components run as one-off ephemeral processes that read `TRIGGER_NAME`
- * from the environment instead.
- */
-export interface KazzleTrigger {
-    /** Stable identifier, unique within the component (kebab-case, e.g. "daily-digest"). */
-    name: string;
-    /** Trigger kind — schedule (cron) or webhook (HTTP POST). */
-    kind: 'schedule' | 'webhook';
-    /** Cron expression (5-field, minute resolution). Required for kind="schedule". */
-    schedule?: string;
-    /** HTTP path on the running server. Required when processMode="persistent". */
-    path?: string;
-}
-export interface KazzleComponent {
-    /** Unique component name within the app */
-    name: string;
-    /** Component type — ui (max 1) or process */
-    type: 'ui' | 'process';
-    /** Entry path within the app directory */
-    path: string;
-    /** Default secret collection + environment for env var injection. */
-    env?: KazzleComponentEnv;
-    /** Commands and optional env overrides for dev and production modes */
-    runtime?: KazzleComponentRuntime;
-    /**
-     * Execution lifecycle for process components.
-     *
-     *   - 'persistent' — long-running server. Triggers are POSTed into the
-     *     server at the declared `path`. This is the default.
-     *   - 'triggered'  — ephemeral one-off run per trigger. The platform
-     *     spawns the entry script with `TRIGGER_NAME`, `RUN_ID`, and an
-     *     optional `WEBHOOK_PAYLOAD` env var, then waits for exit.
-     */
-    processMode?: 'persistent' | 'triggered';
-    /** Schedule and webhook triggers. One component may declare many. */
-    triggers?: KazzleTrigger[];
-}
-export interface KazzleSkill {
-    /** Skill name */
-    name: string;
-    /** Path to the SKILL.md file relative to the app root */
-    path: string;
-}
-export interface KazzleConfig {
-    /** Marketing display name shown in the app catalog. Falls back to the slug when omitted. */
-    name?: string;
-    /** One-line catalog tagline. Required to publish. */
-    subtitle?: string;
-    /** Author-set version label (e.g. "1.2.0"). Display-only; snapshotted on publish. */
-    version?: string;
-    /** Where the published app runs — remote (Fly.io) or local (user computer). Defaults to remote. */
-    target?: 'local' | 'remote';
-    /** Path to the app icon file (png, jpg, svg, webp, ico) */
-    icon?: string;
-    /**
-     * End-user login for this app (via @kazzle/app/auth — Google today).
-     * Distinct from `kazzleAuth`, which gates the launch surface by Kazzle
-     * account; appLogin is the app's OWN users, stored in its own database.
-     * Requires a process + database.
-     */
-    appLogin?: boolean;
-    /** Executable components — UI frontends or background processes */
-    components?: KazzleComponent[];
-    /** AI skill definitions — markdown files the AI reads for domain knowledge */
-    skills?: KazzleSkill[];
-}
-/** Type-safe config helper. Use: export default defineConfig({ ... }) */
-export declare function defineConfig(config: KazzleConfig): KazzleConfig;
+export { AppDefinitionSchema, defineApp, type AppDefinition, type AppDefinitionComponent, type AppDefinitionComponentEnv, type AppDefinitionRuntimeMode, type AppDefinitionSetup, type AppDefinitionSetupField, type AppDefinitionToolSource, type AppDefinitionTrigger, } from './definition';

package/dist/index.js

@@ -1,15 +1,3 @@
-// @kazzle/app — root export. App config contract + `defineConfig`.
-//
-// SOURCE OF TRUTH for the app config types that generated apps author in
-// kazzle.config.ts. The server validates the runtime shape with the Zod
-// `ManifestSchema` in server/apps/apps.manifest.ts; these interfaces are the
-// hand-authored TypeScript mirror app code imports. Keep the two in sync — if
-// you add a config field here, add it to ManifestSchema in the same change.
-//
-// This module must stay dependency-free. Tools live in `@kazzle/app/tools`,
-// the Vite helper in `@kazzle/app/vite` — do not re-export them here or the
-// root import pulls in zod/vite for every consumer. See README.md.
-/** Type-safe config helper. Use: export default defineConfig({ ... }) */
-export function defineConfig(config) {
-    return config;
-}
+// @kazzle/app — canonical app-definition contract.
+// Other helpers stay on their dedicated package subpaths.
+export { AppDefinitionSchema, defineApp, } from './definition';

package/dist/installations.d.ts

@@ -0,0 +1,13 @@
+export declare class InstallationNotConnectedError extends Error {
+    readonly installationId: string;
+    constructor(installationId: string, message?: string);
+}
+/**
+ * A fresh vendor access token for a installation, e.g.
+ * `new Stripe(await getInstallationToken('8f2a…'))`.
+ */
+export declare function getInstallationToken(installationId: string): Promise<string>;
+/** Read values submitted through an app definition's credential form. */
+export declare function getInstallationCredentials<T extends Record<string, unknown> = Record<string, string>>(installationId: string): Promise<T>;
+/** Forget cached tokens (tests, or after a reconnect). */
+export declare function clearInstallationTokenCache(): void;

package/dist/installations.js

@@ -0,0 +1,69 @@
+// @kazzle/app/installations — use the accounts a person connected in Kazzle
+// (Stripe, Gmail, Slack, …) from app code.
+//
+// Kazzle keeps the OAuth tokens; this asks Kazzle for a fresh one and caches it
+// until it expires. Identify the installation by its installation id (the AI that
+// built the app has it from the vault). Requires KAZZLE_API_KEY and
+// KAZZLE_API_URL, both injected into every component at deploy and `kazzle run`.
+//
+// Dependency-free on purpose (uses global fetch). Do not add zod/vite here.
+import { kazzleApiUrl } from './client';
+export class InstallationNotConnectedError extends Error {
+    installationId;
+    constructor(installationId, message) {
+        super(message ?? `Installation ${installationId} is not connected. Connect it on the Integrations page in Kazzle.`);
+        this.installationId = installationId;
+        this.name = 'InstallationNotConnectedError';
+    }
+}
+const DEFAULT_TTL_MS = 60 * 60_000;
+const REFRESH_MARGIN_MS = 60_000;
+const cache = new Map();
+function apiKey() {
+    const key = process.env['KAZZLE_API_KEY'];
+    if (!key) {
+        throw new Error('KAZZLE_API_KEY is not set — installation credentials are only available to deployed Kazzle app components.');
+    }
+    return key;
+}
+/**
+ * A fresh vendor access token for a installation, e.g.
+ * `new Stripe(await getInstallationToken('8f2a…'))`.
+ */
+export async function getInstallationToken(installationId) {
+    const hit = cache.get(installationId);
+    if (hit && hit.expiresAt - Date.now() > REFRESH_MARGIN_MS)
+        return hit.token;
+    const res = await fetch(`${kazzleApiUrl()}/installations/${encodeURIComponent(installationId)}/token`, {
+        headers: { authorization: `Bearer ${apiKey()}` },
+    });
+    if (res.status === 404 || res.status === 409) {
+        const body = await res.json().catch(() => ({}));
+        cache.delete(installationId);
+        throw new InstallationNotConnectedError(installationId, body.message);
+    }
+    if (!res.ok) {
+        throw new Error(`Kazzle installation credential request failed: HTTP ${res.status}`);
+    }
+    const body = await res.json();
+    const expiresAt = body.expiresAt ? Date.parse(body.expiresAt) : Date.now() + DEFAULT_TTL_MS;
+    cache.set(installationId, { token: body.token, expiresAt: Number.isFinite(expiresAt) ? expiresAt : Date.now() + DEFAULT_TTL_MS });
+    return body.token;
+}
+/** Read values submitted through an app definition's credential form. */
+export async function getInstallationCredentials(installationId) {
+    const res = await fetch(`${kazzleApiUrl()}/installations/${encodeURIComponent(installationId)}/credentials`, {
+        headers: { authorization: `Bearer ${apiKey()}` },
+    });
+    if (res.status === 404) {
+        const body = await res.json().catch(() => ({}));
+        throw new InstallationNotConnectedError(installationId, body.message);
+    }
+    if (!res.ok)
+        throw new Error(`Kazzle installation credential request failed: HTTP ${res.status}`);
+    return (await res.json()).values;
+}
+/** Forget cached tokens (tests, or after a reconnect). */
+export function clearInstallationTokenCache() {
+    cache.clear();
+}

package/dist/vendor/kazzle/agents.d.ts

@@ -0,0 +1,38 @@
+import { type KazzleHttp } from './http';
+export interface AgentAvatarConfig {
+    shape: 'round' | 'square';
+    faceColor: string;
+    eyeColor: string;
+}
+export interface AgentWrite {
+    name: string;
+    instructions: string;
+    avatarUrl?: string | null;
+    avatarConfig?: AgentAvatarConfig | null;
+    description?: string | null;
+    modelId?: string | null;
+    skillIds?: string[];
+    appInstallationIds?: string[];
+    computerIds?: string[];
+    browserProfileIds?: string[];
+    enabled?: boolean;
+}
+export type AgentUpdate = Partial<AgentWrite>;
+export interface AgentRow extends AgentWrite {
+    id: string;
+    enabled: boolean;
+    createdAt: number;
+    updatedAt: number;
+    mainThreadId?: string;
+}
+export declare class AgentsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    create(input: AgentWrite): Promise<AgentRow>;
+    list(): Promise<AgentRow[]>;
+    get(agentId: string): Promise<AgentRow>;
+    update(agentId: string, patch: AgentUpdate): Promise<AgentRow>;
+    delete(agentId: string): Promise<{
+        success: boolean;
+    }>;
+}

package/dist/vendor/kazzle/agents.js

@@ -0,0 +1,46 @@
+import { apiPath } from './http';
+function fromApi(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        instructions: row.instructions,
+        avatarUrl: row.avatar_url,
+        avatarConfig: row.avatar_config ? {
+            shape: row.avatar_config.shape,
+            faceColor: row.avatar_config.face_color,
+            eyeColor: row.avatar_config.eye_color,
+        } : row.avatar_config,
+        description: row.description,
+        modelId: row.model_id,
+        skillIds: row.skill_ids ?? [],
+        appInstallationIds: row.app_installation_ids ?? [],
+        computerIds: row.computer_ids ?? [],
+        browserProfileIds: row.browser_profile_ids ?? [],
+        enabled: row.enabled,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        ...(row.main_thread_id ? { mainThreadId: row.main_thread_id } : {}),
+    };
+}
+export class AgentsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async create(input) {
+        return fromApi(await this.http.json('POST', '/agents', input));
+    }
+    async list() {
+        const response = await this.http.json('GET', '/agents');
+        return response.items.map(fromApi);
+    }
+    async get(agentId) {
+        return fromApi(await this.http.json('GET', apiPath `/agents/${agentId}`));
+    }
+    async update(agentId, patch) {
+        return fromApi(await this.http.json('PATCH', apiPath `/agents/${agentId}`, patch));
+    }
+    async delete(agentId) {
+        return this.http.json('DELETE', apiPath `/agents/${agentId}`);
+    }
+}

package/dist/vendor/kazzle/generated/operations.js

@@ -1,9 +1,14 @@
 // GENERATED FILE — do not edit.
-// Source of truth: shared/api/openapi.json (Computers API + Browsers API tags).
+// Source of truth: shared/api/openapi.json (customer API tags).
 // Regenerate with `bun run generate` in packages/kazzle-sdk after the server
 // API surface changes; src/operations.sync.test.ts fails on drift.
 /** Every customer API operation the SDK must cover. */
 export const API_OPERATIONS = [
+    { method: 'GET', path: '/agents' },
+    { method: 'POST', path: '/agents' },
+    { method: 'DELETE', path: '/agents/{agentId}' },
+    { method: 'GET', path: '/agents/{agentId}' },
+    { method: 'PATCH', path: '/agents/{agentId}' },
     { method: 'GET', path: '/browsers' },
     { method: 'POST', path: '/browsers' },
     { method: 'DELETE', path: '/browsers/{browserId}' },
@@ -97,6 +102,18 @@ export const API_OPERATIONS = [
     { method: 'POST', path: '/computers/{computerId}/terminals/{sessionId}/wait' },
     { method: 'POST', path: '/computers/{computerId}/terminals/{sessionId}/write' },
     { method: 'POST', path: '/computers/{computerId}/wake' },
+    { method: 'GET', path: '/threads' },
+    { method: 'POST', path: '/threads' },
+    { method: 'DELETE', path: '/threads/{threadId}' },
+    { method: 'GET', path: '/threads/{threadId}' },
+    { method: 'PATCH', path: '/threads/{threadId}' },
+    { method: 'POST', path: '/threads/{threadId}/approvals' },
+    { method: 'GET', path: '/threads/{threadId}/messages' },
+    { method: 'POST', path: '/threads/{threadId}/messages' },
+    { method: 'POST', path: '/threads/{threadId}/resume' },
+    { method: 'POST', path: '/threads/{threadId}/retry' },
+    { method: 'POST', path: '/threads/{threadId}/stop' },
+    { method: 'GET', path: '/threads/{threadId}/stream' },
 ];
 /** URL segments under /browsers/{browserId}/tabs/{tabId}/. */
 export const TAB_ACTION_SEGMENTS = [

package/dist/vendor/kazzle/index.d.ts

@@ -8,4 +8,7 @@ export { DesktopApi } from './computers.desktop';
 export { Browser, BrowsersApi } from './browsers';
 export { TabsApi } from './browsers.tabs';
 export { ProfilesApi } from './browsers.profiles';
+export { ThreadStream, type ThreadStreamEvent } from './thread-stream';
+export { AgentsApi, type AgentAvatarConfig, type AgentRow, type AgentUpdate, type AgentWrite, } from './agents';
+export { Thread, ThreadsApi, type ThreadCreate, type ThreadDecision, type ThreadMessage, type ThreadRow, type ThreadSegment, type ThreadUpdate, } from './threads';
 export type { ActionResult, BrowserCreateOptions, BrowserCreateResponse, BrowserRow, BrowserState, ComputerCreateResponse, ComputerRow, ExecOptions, FsDeleteResponse, FsGlobResponse, FsGrepMatch, FsGrepResponse, FsReadResponse, FsTransferResponse, FsWriteResponse, ListResponse, OkResponse, ProfileCreateOptions, ProfileCreateResponse, ProfileRow, TabRow, } from './sdk.types';

package/dist/vendor/kazzle/index.js

@@ -1,5 +1,4 @@
-// kazzle — typed client for the Kazzle computers and browsers REST API.
-// Quickstart in README.md; endpoint semantics in docs/platform/computers-api.mdx.
+// kazzle — typed client for Kazzle agents, threads, computers, and browsers.
 export { Kazzle } from './kazzle';
 export { KazzleApiError } from './http';
 export { ExecStream, KazzleExecError } from './sse';
@@ -10,3 +9,6 @@ export { DesktopApi } from './computers.desktop';
 export { Browser, BrowsersApi } from './browsers';
 export { TabsApi } from './browsers.tabs';
 export { ProfilesApi } from './browsers.profiles';
+export { ThreadStream } from './thread-stream';
+export { AgentsApi, } from './agents';
+export { Thread, ThreadsApi, } from './threads';

package/dist/vendor/kazzle/kazzle.d.ts

@@ -1,9 +1,13 @@
 import { type KazzleOptions } from './http';
 import { ComputersApi } from './computers';
 import { BrowsersApi } from './browsers';
+import { AgentsApi } from './agents';
+import { ThreadsApi } from './threads';
 export declare class Kazzle {
     readonly computers: ComputersApi;
     readonly browsers: BrowsersApi;
+    readonly agents: AgentsApi;
+    readonly threads: ThreadsApi;
     /** Resolved API base URL (option, then KAZZLE_API_URL, then https://api.kazzle.app). */
     readonly baseUrl: string;
     constructor(options?: KazzleOptions);

package/dist/vendor/kazzle/kazzle.js

@@ -1,12 +1,15 @@
-// Kazzle SDK entry: `new Kazzle({ apiKey })` → kazzle.computers.* and
-// kazzle.browsers.*. One KazzleHttp instance owns auth and error mapping for
+// Kazzle SDK entry. One KazzleHttp instance owns auth and error mapping for
 // every namespace.
 import { KazzleHttp } from './http';
 import { ComputersApi } from './computers';
 import { BrowsersApi } from './browsers';
+import { AgentsApi } from './agents';
+import { ThreadsApi } from './threads';
 export class Kazzle {
     computers;
     browsers;
+    agents;
+    threads;
     /** Resolved API base URL (option, then KAZZLE_API_URL, then https://api.kazzle.app). */
     baseUrl;
     constructor(options = {}) {
@@ -14,5 +17,7 @@ export class Kazzle {
         this.baseUrl = http.baseUrl;
         this.computers = new ComputersApi(http);
         this.browsers = new BrowsersApi(http);
+        this.agents = new AgentsApi(http);
+        this.threads = new ThreadsApi(http);
     }
 }

package/dist/vendor/kazzle/thread-stream.d.ts

@@ -0,0 +1,11 @@
+export interface ThreadStreamEvent {
+    type: string;
+    data: unknown;
+}
+export declare class ThreadStream implements AsyncIterable<ThreadStreamEvent> {
+    private readonly response;
+    constructor(response: Promise<Response>);
+    [Symbol.asyncIterator](): AsyncIterator<ThreadStreamEvent>;
+    /** Drain the response and return the assistant's text. */
+    text(): Promise<string>;
+}

package/dist/vendor/kazzle/thread-stream.js

@@ -0,0 +1,41 @@
+import { parseSseStream } from './sse';
+function parseData(data) {
+    if (!data)
+        return null;
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+export class ThreadStream {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    async *[Symbol.asyncIterator]() {
+        const response = await this.response;
+        if (!response.body)
+            throw new Error('Thread response has no body stream');
+        for await (const frame of parseSseStream(response.body)) {
+            yield { type: frame.event, data: parseData(frame.data) };
+        }
+    }
+    /** Drain the response and return the assistant's text. */
+    async text() {
+        const chunks = [];
+        for await (const event of this) {
+            if (event.type === 'error') {
+                const message = typeof event.data === 'string' ? event.data : 'Thread response failed';
+                throw new Error(message);
+            }
+            if (event.type !== 'text' || !event.data || typeof event.data !== 'object')
+                continue;
+            const content = event.data.content;
+            if (typeof content === 'string')
+                chunks.push(content);
+        }
+        return chunks.join('');
+    }
+}

package/dist/vendor/kazzle/threads.d.ts

@@ -0,0 +1,77 @@
+import { ThreadStream } from './thread-stream';
+import { type KazzleHttp } from './http';
+export interface ThreadCreate {
+    title?: string;
+    agentId?: string;
+}
+export interface ThreadUpdate {
+    title?: string;
+    agentId?: string | null;
+    modelId?: string | null;
+    archived?: boolean;
+}
+export interface ThreadRow {
+    id: string;
+    title: string;
+    agentId: string | null;
+    modelId: string | null;
+    mode: string;
+    status: string | null;
+    archived: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ThreadSegment {
+    id: string;
+    type: string;
+    content: unknown;
+    order: number;
+    createdAt: number;
+}
+export interface ThreadMessage {
+    id: string;
+    role: string;
+    modelId: string | null;
+    createdAt: number;
+    segments: ThreadSegment[];
+}
+export interface ThreadDecision {
+    toolCallId: string;
+    elementId: string;
+    input?: Record<string, unknown>;
+}
+export declare class Thread {
+    private readonly http;
+    readonly id: string;
+    constructor(http: KazzleHttp, id: string);
+    send(content: string, options?: {
+        messageId?: string;
+    }): ThreadStream;
+    retry(messageId: string, options?: {
+        content?: string;
+    }): ThreadStream;
+    watch(): ThreadStream;
+    resume(decisions?: ThreadDecision[]): ThreadStream;
+    approve(decisions: ThreadDecision[]): ThreadStream;
+    stop(): Promise<{
+        success: boolean;
+    }>;
+    get(): Promise<ThreadRow>;
+    update(patch: ThreadUpdate): Promise<ThreadRow>;
+    delete(): Promise<{
+        success: boolean;
+    }>;
+    messages(): Promise<ThreadMessage[]>;
+}
+export declare class ThreadsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    create(input?: ThreadCreate): Promise<Thread>;
+    list(): Promise<ThreadRow[]>;
+    get(threadId: string): Promise<ThreadRow>;
+    update(threadId: string, patch: ThreadUpdate): Promise<ThreadRow>;
+    delete(threadId: string): Promise<{
+        success: boolean;
+    }>;
+    fromId(threadId: string): Thread;
+}

package/dist/vendor/kazzle/threads.js

@@ -0,0 +1,70 @@
+import { ThreadStream } from './thread-stream';
+import { apiPath } from './http';
+function fromApi(row) {
+    return {
+        id: row.id,
+        title: row.title,
+        agentId: row.agent_id,
+        modelId: row.model_id,
+        mode: row.mode,
+        status: row.status,
+        archived: row.archived,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export class Thread {
+    http;
+    id;
+    constructor(http, id) {
+        this.http = http;
+        this.id = id;
+    }
+    send(content, options = {}) {
+        return new ThreadStream(this.http.request('POST', apiPath `/threads/${this.id}/messages`, { content, ...options }));
+    }
+    retry(messageId, options = {}) {
+        return new ThreadStream(this.http.request('POST', apiPath `/threads/${this.id}/retry`, { messageId, ...options }));
+    }
+    watch() { return new ThreadStream(this.http.request('GET', apiPath `/threads/${this.id}/stream`)); }
+    resume(decisions) { return new ThreadStream(this.http.request('POST', apiPath `/threads/${this.id}/resume`, { decisions })); }
+    approve(decisions) { return new ThreadStream(this.http.request('POST', apiPath `/threads/${this.id}/approvals`, { decisions })); }
+    stop() { return this.http.json('POST', apiPath `/threads/${this.id}/stop`, {}); }
+    get() { return this.http.json('GET', apiPath `/threads/${this.id}`).then(fromApi); }
+    update(patch) { return this.http.json('PATCH', apiPath `/threads/${this.id}`, patch).then(fromApi); }
+    delete() { return this.http.json('DELETE', apiPath `/threads/${this.id}`); }
+    async messages() {
+        const response = await this.http.json('GET', apiPath `/threads/${this.id}/messages`);
+        return response.items.map(message => ({
+            id: message.id,
+            role: message.role,
+            modelId: message.model_id,
+            createdAt: message.created_at,
+            segments: message.segments.map(segment => ({
+                id: segment.id,
+                type: segment.type,
+                content: segment.content,
+                order: segment.order,
+                createdAt: segment.created_at,
+            })),
+        }));
+    }
+}
+export class ThreadsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async create(input = {}) {
+        const row = await this.http.json('POST', '/threads', input);
+        return new Thread(this.http, row.id);
+    }
+    async list() {
+        const response = await this.http.json('GET', '/threads');
+        return response.items.map(fromApi);
+    }
+    get(threadId) { return this.fromId(threadId).get(); }
+    update(threadId, patch) { return this.fromId(threadId).update(patch); }
+    delete(threadId) { return this.fromId(threadId).delete(); }
+    fromId(threadId) { return new Thread(this.http, threadId); }
+}

package/dist/vite.d.ts

@@ -29,7 +29,7 @@ export type KazzleAppPwaOptions = {
 /**
  * Kazzle preview/runtime Vite config. Spread the result into your Vite config:
  *
- *   export default defineConfig(({ command }) => ({
+ *   export default defineApp(({ command }) => ({
  *     plugins: [react(), tailwindcss(), ...kazzleAppPwa()],
  *     ...kazzleAppVite(command, { apiComponent: 'server', proxyPaths: ['/todos'] }),
  *   }));

package/dist/vite.js

@@ -32,7 +32,7 @@ function componentUrlEnvName(componentName) {
 /**
  * Kazzle preview/runtime Vite config. Spread the result into your Vite config:
  *
- *   export default defineConfig(({ command }) => ({
+ *   export default defineApp(({ command }) => ({
  *     plugins: [react(), tailwindcss(), ...kazzleAppPwa()],
  *     ...kazzleAppVite(command, { apiComponent: 'server', proxyPaths: ['/todos'] }),
  *   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kazzle/app",
-  "version": "0.1.944",
+  "version": "0.1.946",
   "description": "Contracts, tool helpers, Vite helper, and templates for building Kazzle apps.",
   "license": "UNLICENSED",
   "repository": {
@@ -16,6 +16,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./definition": {
+      "types": "./dist/definition.d.ts",
+      "import": "./dist/definition.js"
+    },
     "./tools": {
       "types": "./dist/tools.d.ts",
       "import": "./dist/tools.js"
@@ -24,9 +28,9 @@
       "types": "./dist/client.d.ts",
       "import": "./dist/client.js"
     },
-    "./connections": {
-      "types": "./dist/connections.d.ts",
-      "import": "./dist/connections.js"
+    "./installations": {
+      "types": "./dist/installations.d.ts",
+      "import": "./dist/installations.js"
     },
     "./auth": {
       "types": "./dist/auth.d.ts",

package/templates/ai-app/README.md

@@ -0,0 +1,3 @@
+# {{APP_NAME}}
+
+Describe what this app does and how people use it.