runwork 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Runwork
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,134 @@
+# runwork
+
+The CLI for [Runwork](https://www.runwork.ai) -- develop, preview, and deploy Runwork apps from your local machine using any editor or AI coding tool.
+
+## The Runwork Platform
+
+Runwork is an AI workspace that brings AI agents, custom apps, and human teams into one place. Teams talk to the workspace to get quick answers, automate recurring work, or spin up full custom tools -- without switching between dozens of SaaS products.
+
+This CLI is the local development interface to the platform. You write TypeScript, and the platform handles deployment, infrastructure, AI, and integrations:
+
+- **Full-stack apps, zero infrastructure** -- Data storage, file hosting, background jobs, durable workflows, AI, and 3,200+ third-party integrations are all built into the platform. You write application code; Runwork runs it.
+- **Zero to app in seconds** -- Describe what you need and Runwork generates it. Developers customize with code using the [`@runworkai/framework`](https://www.npmjs.com/package/@runworkai/framework).
+- **Instant deployments** -- Push code and get a live URL. Preview environments while you develop, production at the edge.
+- **Built-in AI agents** -- Conversational agents that read data, take actions, and coordinate across apps. No API keys or model configuration to manage.
+- **Connected apps** -- Apps in a workspace share entities, call each other's APIs, communicate through channels, and present a unified experience.
+- **Every app is an MCP server and a skill** -- Deploy an app, and it automatically becomes an MCP server and a callable skill. Your AI tools and workspace agents can use your apps directly -- completing the loop from development to AI consumption.
+- **AI-native local development** -- Every scaffolded project includes `CLAUDE.md`, `AGENTS.md`, and full framework type definitions in `.runwork/types/`. AI coding tools (Claude Code, Cursor, Codex, or any editor) understand the Runwork framework out of the box -- no setup, no guessing. The CLI keeps code and preview in sync while you or your AI agent write code.
+
+## Install
+
+### macOS / Linux (recommended)
+
+```bash
+curl -fsSL https://runwork.ai/install.sh | sh
+```
+
+### macOS (Homebrew)
+
+```bash
+brew install runwork-ai/tap/runwork
+```
+
+### npm
+
+```bash
+npm install -g runwork
+```
+
+### Direct download
+
+Download from [GitHub Releases](https://github.com/runwork-ai/cli/releases).
+
+## Quick Start
+
+```bash
+runwork login          # Authenticate with Runwork
+runwork init           # Create a new app
+runwork dev            # Start developing with live preview
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `runwork login` | Authenticate with the Runwork platform via browser OAuth |
+| `runwork init` | Create a new app -- prompts for name and workspace, scaffolds the project |
+| `runwork clone` | Clone an existing Runwork app to your machine |
+| `runwork dev` | Start local development with live preview and auto-sync |
+| `runwork deploy` | Deploy to production |
+| `runwork logout` | Remove stored credentials |
+
+### `runwork dev`
+
+The main development command. When you run `runwork dev`:
+
+1. Pulls the latest code from the Runwork git remote
+2. Starts a cloud preview sandbox
+3. Watches local files for changes
+4. Auto-commits and pushes changes to sync with the preview
+5. Prints the preview URL for browser access
+6. Populates `.runwork/types/` with framework type definitions for AI coding tools
+
+Edit files in your editor, and changes appear in the preview automatically.
+
+## How It Works
+
+Runwork apps are full-stack TypeScript projects built with the [`@runworkai/framework`](https://www.npmjs.com/package/@runworkai/framework). The CLI handles the development lifecycle:
+
+- **Git-based sync** -- Your app is backed by a git repository on the Runwork platform. The CLI uses git push/pull to sync code between your machine and the cloud.
+- **Cloud preview** -- `runwork dev` spins up a live preview sandbox. Changes sync automatically as you edit files.
+- **Framework types** -- The CLI populates `.runwork/types/` with framework type definitions so AI coding tools can understand the full API without needing `node_modules`.
+- **Zero config** -- Project settings live in `.runwork.json`. No deployment scripts to manage locally.
+
+## What You Can Build
+
+Every Runwork app gets built-in access to:
+
+- **Data storage** -- Persistent entities with search, sort, filter, and pagination
+- **AI agents** -- Conversational agents with tool use, memory, and integration access
+- **Backend AI** -- `generateText`, `generateObject`, `streamText` for routes, workflows, and jobs
+- **Durable workflows** -- Multi-step processes that survive failures, with retries and event waiting
+- **Scheduled jobs** -- Cron-based background tasks
+- **File storage** -- Upload and manage files and media
+- **Public endpoints** -- Authenticated APIs for external consumers
+- **Cross-app workspaces** -- Shared entities, channels, and notifications between apps
+- **3,200+ integrations** -- OAuth-managed connections to third-party services
+
+## Project Structure
+
+After `runwork init`, your project looks like this:
+
+```
+my-app/
+  .runwork.json          # App config (app ID, workspace, remote URL)
+  .runwork/
+    blueprint.json       # App feature blueprint (entities, agents, etc.)
+    types/               # Framework type definitions (auto-populated)
+  worker/                # Backend code
+    entities.ts          # Data entities
+    routes.ts            # API routes
+    agents.ts            # AI agents
+    workflows.ts         # Durable workflows
+    schedules.ts         # Scheduled jobs
+    endpoints.ts         # Public API endpoints
+  src/                   # Frontend React code
+    pages/               # Page components
+    components/          # UI components
+  shared/types.ts        # Shared types between frontend and backend
+```
+
+## Requirements
+
+- Git
+- A [Runwork](https://www.runwork.ai) account
+- Node.js 18+ (only required when installing via npm)
+
+## Links
+
+- [Runwork Platform](https://www.runwork.ai)
+- [`@runworkai/framework`](https://www.npmjs.com/package/@runworkai/framework) -- The TypeScript framework for building Runwork apps
+
+## License
+
+MIT

package/bin/runwork.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/index.js');

package/bundled-types/agents.d.ts

@@ -0,0 +1,3 @@
+export { INITIAL_AGENT_STATE, createAgentRegistry, getEntityToolDefs, getIntegrationToolDefs, getCustomToolDefs, getAgentToolDefs, toolDefToMeta, getAgentToolMeta, agentRoutes, entityListSchema, entityGetSchema, integrationApiSchema, } from './core-agent';
+export type { AgentState, AgentMessage, MemoryStrategy, AgentDefinition, AgentToolDefinition, AgentToolContext, AgentRegistry, RegisterAgentRequest, AgentToolMeta, AgentToolDef, AgentToolStatus, IntegrationStatus, AgentRuntimeStatus, } from './core-agent';
+export { BaseAgent } from './core-base-agent';

package/bundled-types/ai.d.ts

@@ -0,0 +1,2 @@
+export { tool, generateText, streamText, generateObject, aiRoutes, } from './core-ai';
+export type { ModelMessage, ModelMessage as CoreMessage, Tool, ToolSet, ToolChoice, TextPart, ImagePart, FilePart, UserContent, DataContent, ChatMessage, AICallSettings, GenerateTextOptions, StreamTextOptions, GenerateObjectOptions, } from './core-ai';

package/bundled-types/app-registry.d.ts

@@ -0,0 +1,74 @@
+/**
+ * App Registry - Global registration point for user-defined application code.
+ *
+ * Framework core files call the getRegistered*() functions to access user code
+ * instead of importing directly from user files. This enables the framework
+ * to be distributed as an npm package while still accessing user-defined
+ * agents, entities, routes, etc.
+ *
+ * Users register their code via createApp() which calls setAppConfig() internally.
+ */
+import type { AgentDefinition } from './core-agent';
+import type { EntityClass } from './core-entities';
+import type { ScheduledJob } from './core-scheduler';
+import type { WorkflowDefinition } from './core-workflow-types';
+import type { EndpointDefinition } from './core-endpoints';
+import type { IntegrationRequirement } from './core-integrations';
+import type { Hono } from 'hono';
+import type { Env } from './core-utils';
+/** Component metadata for workspace registration */
+export interface ComponentMetadata {
+    tag: string;
+    description?: string;
+    attributes?: Record<string, string>;
+}
+/** Component definition for registerable UI components */
+export interface ComponentDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    chatId?: string;
+    frontend: boolean;
+    backend: boolean;
+    metadata: ComponentMetadata;
+}
+/** A user-defined route function or an EndpointDefinition */
+export type AppRoute = (app: Hono<{
+    Bindings: Env;
+}>) => void;
+export type RouteEntry = AppRoute | EndpointDefinition;
+/**
+ * Configuration for all registerable application features.
+ */
+export interface AppConfig {
+    agents: AgentDefinition[];
+    entities: Array<EntityClass<{
+        id: string;
+    }>>;
+    routes: RouteEntry[];
+    endpoints: EndpointDefinition[];
+    workflows: WorkflowDefinition[];
+    schedules: ScheduledJob[];
+    integrationRequirements: IntegrationRequirement[];
+    components: ComponentDefinition[];
+}
+/**
+ * Store the app configuration. Called internally by createApp().
+ * Should not be called directly by user code.
+ */
+export declare function setAppConfig(config: AppConfig): void;
+/**
+ * Retrieve the full app configuration.
+ * Throws if createApp() has not been called yet.
+ */
+export declare function getAppConfig(): AppConfig;
+export declare function getRegisteredAgents(): AgentDefinition[];
+export declare function getRegisteredEntities(): Array<EntityClass<{
+    id: string;
+}>>;
+export declare function getRegisteredRoutes(): RouteEntry[];
+export declare function getRegisteredEndpoints(): EndpointDefinition[];
+export declare function getRegisteredWorkflows(): WorkflowDefinition[];
+export declare function getRegisteredSchedules(): ScheduledJob[];
+export declare function getRegisteredIntegrationRequirements(): IntegrationRequirement[];
+export declare function getRegisteredComponents(): ComponentDefinition[];

package/bundled-types/channels.d.ts

@@ -0,0 +1,2 @@
+export { postToChannel } from './core-channels';
+export type { PostToChannelParams } from './core-channels';

package/bundled-types/components.d.ts

@@ -0,0 +1 @@
+export { componentRoutes } from './core-components';

package/bundled-types/core-agent.d.ts

@@ -0,0 +1,265 @@
+/**
+ * Core Agent Types and Utilities
+ * DO NOT MODIFY THIS FILE - You may break the agent functionality
+ *
+ * This module provides types and utilities for AI agents.
+ * The actual agent implementation is in core-base-agent.ts.
+ *
+ * @example
+ * ```typescript
+ * // In agents.ts
+ * import type { AgentDefinition } from './core-agent';
+ *
+ * const supportAgent: AgentDefinition = {
+ *   name: 'support-assistant',
+ *   description: 'Helps users with common questions',
+ *   systemPrompt: 'You are a helpful support assistant...',
+ *   integrations: ['slack', 'github'],
+ *   entities: ['ticket', 'user'],
+ * };
+ *
+ * export const APP_AGENTS: AgentDefinition[] = [supportAgent];
+ * ```
+ */
+import { z } from 'zod';
+import type { Env } from './core-utils';
+import type { IntegrationClient } from './core-integrations';
+/**
+ * Agent state persisted across conversations
+ */
+export interface AgentState {
+    /** Conversation history */
+    messages: AgentMessage[];
+    /** Custom memory data */
+    memory: Record<string, unknown>;
+    /** Session metadata */
+    sessionId: string;
+    /** User identifier for per-user memory */
+    userId?: string;
+    /** Last activity timestamp */
+    lastActivityAt: number;
+}
+/**
+ * Message in agent conversation
+ */
+export interface AgentMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    timestamp: number;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+    }>;
+    toolResults?: Array<{
+        id: string;
+        result: unknown;
+    }>;
+}
+/**
+ * Memory strategy for agents
+ * - session: Memory resets when conversation ends
+ * - user: Memory persists per user across conversations
+ * - shared: Memory is shared across all users
+ */
+export type MemoryStrategy = 'session' | 'user' | 'shared';
+/**
+ * Agent definition schema
+ */
+export interface AgentDefinition {
+    /** Unique agent name (kebab-case, e.g., 'support-assistant') */
+    name: string;
+    /** Human-readable description */
+    description: string;
+    /** System prompt defining agent behavior */
+    systemPrompt: string;
+    /** Agent type for UI hints */
+    type?: 'conversational' | 'task';
+    /** Integration IDs the agent can access */
+    integrations?: string[];
+    /** Entity names the agent can read/write */
+    entities?: string[];
+    /** Memory strategy */
+    memoryStrategy?: MemoryStrategy;
+    /** Custom tools for this agent */
+    customTools?: AgentToolDefinition[];
+}
+/**
+ * Custom tool definition for agents
+ */
+export interface AgentToolDefinition {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<z.ZodRawShape>;
+    execute: (args: Record<string, unknown>, context: AgentToolContext) => Promise<unknown>;
+}
+/**
+ * Context passed to tool execution
+ */
+export interface AgentToolContext {
+    env: Env;
+    agentName: string;
+    integrationClient: IntegrationClient;
+    state: AgentState;
+}
+/**
+ * Initial state for new agent instances
+ */
+export declare const INITIAL_AGENT_STATE: AgentState;
+/**
+ * Agent registry - maps agent names to their definitions
+ */
+export type AgentRegistry = Record<string, AgentDefinition>;
+/**
+ * Create an agent registry from an array of definitions.
+ *
+ * NOTE: This function is defensive against undefined/null inputs because it's called
+ * at module-level in core-base-agent.ts. During Vite HMR, when files are being rewritten,
+ * there's a race condition where APP_AGENTS may be undefined momentarily. Without
+ * this guard, the worker crashes with "definitions is not iterable", which triggers
+ * cascading HMR failures and eventually causes "@cloudflare/vite-plugin" to lose its
+ * miniflare instance ("Expected `miniflare` to be defined" error).
+ */
+export declare function createAgentRegistry(definitions?: AgentDefinition[] | null): AgentRegistry;
+/**
+ * Workspace agent registration request
+ */
+export interface RegisterAgentRequest {
+    appId: string;
+    appName: string;
+    agentName: string;
+    description: string;
+    type: 'conversational' | 'task';
+    integrations: string[];
+    entities: string[];
+    tools?: AgentToolMeta[];
+}
+/**
+ * Tool metadata for API responses (JSON-serializable, no Zod)
+ */
+export interface AgentToolMeta {
+    name: string;
+    description: string;
+    source: 'entity' | 'integration' | 'custom';
+    sourceId?: string;
+    parameters: {
+        type: 'object';
+        properties: Record<string, {
+            type: string;
+            description?: string;
+        }>;
+        required?: string[];
+    };
+}
+/**
+ * Tool definition with Zod schema (for buildTools)
+ */
+export interface AgentToolDef {
+    name: string;
+    description: string;
+    source: 'entity' | 'integration' | 'custom';
+    sourceId?: string;
+    parameters: z.ZodObject<z.ZodRawShape>;
+}
+/** Zod schema for entity list tool */
+export declare const entityListSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    cursor?: string | undefined;
+    limit?: number | undefined;
+}, {
+    cursor?: string | undefined;
+    limit?: number | undefined;
+}>;
+/** Zod schema for entity get tool */
+export declare const entityGetSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+/**
+ * Get tool definitions for entity access
+ */
+export declare function getEntityToolDefs(entities: string[]): AgentToolDef[];
+/** Zod schema for integration API tool */
+export declare const integrationApiSchema: z.ZodObject<{
+    method: z.ZodDefault<z.ZodEnum<["GET", "POST", "PUT", "PATCH", "DELETE"]>>;
+    endpoint: z.ZodString;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    method: "POST" | "GET" | "PUT" | "PATCH" | "DELETE";
+    endpoint: string;
+    data?: Record<string, unknown> | undefined;
+}, {
+    endpoint: string;
+    data?: Record<string, unknown> | undefined;
+    method?: "POST" | "GET" | "PUT" | "PATCH" | "DELETE" | undefined;
+}>;
+/**
+ * Get tool definitions for integration access
+ */
+export declare function getIntegrationToolDefs(integrations: string[]): AgentToolDef[];
+/**
+ * Get tool definitions from custom tools (extracts metadata from AgentToolDefinition)
+ */
+export declare function getCustomToolDefs(customTools: AgentToolDefinition[]): AgentToolDef[];
+/**
+ * Get all tool definitions for an agent
+ */
+export declare function getAgentToolDefs(agent: AgentDefinition): AgentToolDef[];
+/**
+ * Convert tool definition to JSON-serializable metadata
+ */
+export declare function toolDefToMeta(def: AgentToolDef): AgentToolMeta;
+/**
+ * Get all tool metadata for an agent (JSON-serializable)
+ * Use this for API responses and workspace registration
+ */
+export declare function getAgentToolMeta(agent: AgentDefinition): AgentToolMeta[];
+/**
+ * Tool availability status at runtime
+ */
+export interface AgentToolStatus {
+    name: string;
+    source: 'entity' | 'integration' | 'custom';
+    sourceId?: string;
+    available: boolean;
+    reason?: string;
+}
+/**
+ * Integration connection status
+ */
+export interface IntegrationStatus {
+    id: string;
+    connected: boolean;
+    reason?: string;
+}
+/**
+ * Agent runtime status - actual availability of capabilities
+ */
+export interface AgentRuntimeStatus {
+    /** Agent name */
+    name: string;
+    /** Whether agent definition was found */
+    initialized: boolean;
+    /** Integration connection status */
+    integrations: IntegrationStatus[];
+    /** Tool availability status */
+    tools: AgentToolStatus[];
+    /** AI proxy configured */
+    aiProxyConfigured: boolean;
+    /** Timestamp of status check */
+    checkedAt: number;
+}
+import type { Hono } from 'hono';
+/**
+ * Mount agent routes on the Hono app
+ * Provides REST API for AI agent interactions
+ */
+export declare function agentRoutes(app: Hono<{
+    Bindings: Env;
+}>): void;

package/bundled-types/core-ai.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Core AI Utilities
+ *
+ * Simple LLM helpers for vibe-apps. Provides generateText(), streamText(), and generateObject()
+ * functions that work with the platform's AI proxy - no API keys needed.
+ *
+ * Uses the same AI proxy infrastructure as agents, but without the agent overhead.
+ * Ideal for simple completion tasks, text analysis, and structured output generation.
+ *
+ * @example
+ * ```typescript
+ * import { generateText, streamText, generateObject } from './core-ai';
+ *
+ * // Simple completion
+ * const result = await generateText(env, {
+ *   prompt: 'Summarize this: ...',
+ * });
+ * console.log(result.text);
+ *
+ * // Streaming
+ * const stream = await streamText(env, {
+ *   prompt: 'Write a story about...',
+ * });
+ * for await (const chunk of stream.textStream) {
+ *   console.log(chunk);
+ * }
+ *
+ * // Structured output
+ * import { z } from 'zod';
+ * const result = await generateObject(env, {
+ *   prompt: 'Extract entities from: ...',
+ *   schema: z.object({
+ *     people: z.array(z.string()),
+ *     places: z.array(z.string()),
+ *   }),
+ * });
+ * console.log(result.object);
+ * ```
+ */
+import { type ModelMessage, type UserContent, type ToolSet, type ToolChoice } from 'ai';
+import type { Hono } from 'hono';
+import type { z } from 'zod';
+import { type Env } from './core-utils';
+export { tool, type ModelMessage, type ModelMessage as CoreMessage, type Tool, type ToolSet, type ToolChoice, type TextPart, type ImagePart, type FilePart, type UserContent, type DataContent, } from 'ai';
+/**
+ * Message format for chat-style completions
+ */
+export interface ChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+/**
+ * Call settings for LLM requests
+ */
+export interface AICallSettings {
+    maxOutputTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    presencePenalty?: number;
+    frequencyPenalty?: number;
+    stopSequences?: string[];
+    seed?: number;
+    maxRetries?: number;
+    abortSignal?: AbortSignal;
+}
+/**
+ * Options for text generation
+ */
+export interface GenerateTextOptions extends AICallSettings {
+    /** Text prompt string, or content parts array for multimodal input (images, files) */
+    prompt?: UserContent;
+    /** Chat-style messages (alternative to prompt) - use for multi-turn or complex multimodal */
+    messages?: Array<ChatMessage | ModelMessage>;
+    /** System prompt for context/behavior */
+    system?: string;
+    /** Tools for function calling */
+    tools?: ToolSet;
+    /** How the model should choose which tool to use */
+    toolChoice?: ToolChoice<ToolSet>;
+    /** Maximum number of tool-use steps */
+    maxSteps?: number;
+}
+/**
+ * Options for streaming text generation (same parameters as GenerateTextOptions)
+ */
+export type StreamTextOptions = GenerateTextOptions;
+/**
+ * Options for structured object generation
+ */
+export interface GenerateObjectOptions<T> extends Omit<AICallSettings, 'stopSequences'> {
+    /** Text prompt string, or content parts array for multimodal input (images, files) */
+    prompt?: UserContent;
+    /** Chat-style messages (alternative to prompt) - use for multi-turn or complex multimodal */
+    messages?: Array<ChatMessage | ModelMessage>;
+    /** System prompt for context/behavior */
+    system?: string;
+    /** Zod schema for structured output */
+    schema: z.ZodType<T>;
+}
+/**
+ * Generate text completion using the AI proxy.
+ *
+ * @param env - Worker environment bindings
+ * @param options - Generation options (prompt, messages, system)
+ * @returns AI SDK result with text, usage stats, etc.
+ *
+ * @example
+ * ```typescript
+ * const result = await generateText(env, {
+ *   prompt: 'Explain quantum computing in simple terms',
+ * });
+ * console.log(result.text);
+ * ```
+ */
+export declare function generateText(env: Env, options: GenerateTextOptions): Promise<import("ai").GenerateTextResult<ToolSet, never>>;
+/**
+ * Stream text generation using the AI proxy.
+ *
+ * @param env - Worker environment bindings
+ * @param options - Generation options (prompt, messages, system)
+ * @returns AI SDK streaming result with textStream, fullStream, etc.
+ *
+ * @example
+ * ```typescript
+ * const result = await streamText(env, {
+ *   prompt: 'Write a poem about the ocean',
+ * });
+ *
+ * // Option 1: Iterate over text chunks
+ * for await (const chunk of result.textStream) {
+ *   process.stdout.write(chunk);
+ * }
+ *
+ * // Option 2: Return as HTTP streaming response
+ * return result.toTextStreamResponse();
+ * ```
+ */
+export declare function streamText(env: Env, options: StreamTextOptions): Promise<import("ai").StreamTextResult<ToolSet, never>>;
+/**
+ * Generate structured output (JSON) using the AI proxy.
+ * Uses Zod schema for type-safe structured generation.
+ *
+ * @param env - Worker environment bindings
+ * @param options - Generation options including Zod schema
+ * @returns AI SDK result with typed object, usage stats, etc.
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const result = await generateObject(env, {
+ *   prompt: 'Extract contact info from: John Smith, john@example.com, 555-1234',
+ *   schema: z.object({
+ *     name: z.string(),
+ *     email: z.string().email(),
+ *     phone: z.string().optional(),
+ *   }),
+ * });
+ * console.log(result.object); // { name: 'John Smith', email: 'john@example.com', phone: '555-1234' }
+ * ```
+ */
+export declare function generateObject<T>(env: Env, options: GenerateObjectOptions<T>): Promise<import("ai").GenerateObjectResult<(T extends string ? "enum" : "object") extends infer T_1 ? T_1 extends (T extends string ? "enum" : "object") ? T_1 extends "array" ? T[] : T : never : never>>;
+/**
+ * Mount AI routes on the Hono app.
+ * Provides /api/ai/generate and /api/ai/stream endpoints.
+ */
+export declare function aiRoutes(app: Hono<{
+    Bindings: Env;
+}>): void;