@objectstack/service-ai 4.0.2 → 4.0.4

package/dist/index.cjs

@@ -3,6 +3,9 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,330 +20,1077 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AIService: () => AIService,
-  AIServicePlugin: () => AIServicePlugin,
-  AgentRuntime: () => AgentRuntime,
-  AiConversationObject: () => AiConversationObject,
-  AiMessageObject: () => AiMessageObject,
-  DATA_CHAT_AGENT: () => DATA_CHAT_AGENT,
+// src/tools/data-tools.ts
+var data_tools_exports = {};
+__export(data_tools_exports, {
+  AGGREGATE_DATA_TOOL: () => AGGREGATE_DATA_TOOL,
   DATA_TOOL_DEFINITIONS: () => DATA_TOOL_DEFINITIONS,
-  InMemoryConversationService: () => InMemoryConversationService,
-  METADATA_ASSISTANT_AGENT: () => METADATA_ASSISTANT_AGENT,
-  METADATA_TOOL_DEFINITIONS: () => METADATA_TOOL_DEFINITIONS,
-  MemoryLLMAdapter: () => MemoryLLMAdapter,
-  ObjectQLConversationService: () => ObjectQLConversationService,
-  ToolRegistry: () => ToolRegistry,
-  VercelLLMAdapter: () => VercelLLMAdapter,
-  addFieldTool: () => addFieldTool,
-  buildAIRoutes: () => buildAIRoutes,
-  buildAgentRoutes: () => buildAgentRoutes,
-  createObjectTool: () => createObjectTool,
-  deleteFieldTool: () => deleteFieldTool,
-  describeMetadataObjectTool: () => describeMetadataObjectTool,
-  encodeStreamPart: () => encodeStreamPart,
-  encodeVercelDataStream: () => encodeVercelDataStream,
-  listMetadataObjectsTool: () => listMetadataObjectsTool,
-  modifyFieldTool: () => modifyFieldTool,
-  registerDataTools: () => registerDataTools,
-  registerMetadataTools: () => registerMetadataTools
+  GET_RECORD_TOOL: () => GET_RECORD_TOOL,
+  QUERY_RECORDS_TOOL: () => QUERY_RECORDS_TOOL,
+  registerDataTools: () => registerDataTools
 });
-module.exports = __toCommonJS(index_exports);
-
-// src/ai-service.ts
-var import_core = require("@objectstack/core");
-
-// src/adapters/memory-adapter.ts
-var MemoryLLMAdapter = class {
-  constructor() {
-    this.name = "memory";
-  }
-  async chat(messages, options) {
-    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
-    const userContent = lastUserMessage?.content;
-    const text = typeof userContent === "string" ? userContent : "(complex content)";
-    const content = lastUserMessage ? `[memory] ${text}` : "[memory] (no user message)";
-    return {
-      content,
-      model: options?.model ?? "memory",
-      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+function createQueryRecordsHandler(ctx) {
+  return async (args) => {
+    const {
+      objectName,
+      where,
+      fields,
+      orderBy,
+      limit,
+      offset
+    } = args;
+    const rawLimit = limit ?? DEFAULT_QUERY_LIMIT;
+    const safeLimit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(Math.floor(rawLimit), MAX_QUERY_LIMIT) : DEFAULT_QUERY_LIMIT;
+    const safeOffset = Number.isFinite(offset) && offset >= 0 ? Math.floor(offset) : void 0;
+    const records = await ctx.dataEngine.find(objectName, {
+      where,
+      fields,
+      orderBy,
+      limit: safeLimit,
+      offset: safeOffset
+    });
+    return JSON.stringify({ count: records.length, records });
+  };
+}
+function createGetRecordHandler(ctx) {
+  return async (args) => {
+    const { objectName, recordId, fields } = args;
+    const record = await ctx.dataEngine.findOne(objectName, {
+      where: { id: recordId },
+      fields
+    });
+    if (!record) {
+      return JSON.stringify({ error: `Record "${recordId}" not found in "${objectName}"` });
+    }
+    return JSON.stringify(record);
+  };
+}
+function createAggregateDataHandler(ctx) {
+  return async (args) => {
+    const { objectName, aggregations, groupBy, where } = args;
+    for (const a of aggregations) {
+      if (!VALID_AGG_FUNCTIONS.has(a.function)) {
+        return JSON.stringify({
+          error: `Invalid aggregation function "${a.function}". Allowed: ${[...VALID_AGG_FUNCTIONS].join(", ")}`
+        });
+      }
+    }
+    const result = await ctx.dataEngine.aggregate(objectName, {
+      where,
+      groupBy,
+      aggregations: aggregations.map((a) => ({
+        function: a.function,
+        field: a.field,
+        alias: a.alias
+      }))
+    });
+    return JSON.stringify(result);
+  };
+}
+function registerDataTools(registry, context) {
+  registry.register(QUERY_RECORDS_TOOL, createQueryRecordsHandler(context));
+  registry.register(GET_RECORD_TOOL, createGetRecordHandler(context));
+  registry.register(AGGREGATE_DATA_TOOL, createAggregateDataHandler(context));
+}
+var MAX_QUERY_LIMIT, DEFAULT_QUERY_LIMIT, QUERY_RECORDS_TOOL, GET_RECORD_TOOL, AGGREGATE_DATA_TOOL, DATA_TOOL_DEFINITIONS, VALID_AGG_FUNCTIONS;
+var init_data_tools = __esm({
+  "src/tools/data-tools.ts"() {
+    "use strict";
+    MAX_QUERY_LIMIT = 200;
+    DEFAULT_QUERY_LIMIT = 20;
+    QUERY_RECORDS_TOOL = {
+      name: "query_records",
+      description: "Query records from a data object with optional filters, field selection, sorting, and pagination. Returns an array of matching records.",
+      parameters: {
+        type: "object",
+        properties: {
+          objectName: {
+            type: "string",
+            description: "The snake_case name of the object to query"
+          },
+          where: {
+            type: "object",
+            description: 'Filter conditions as key-value pairs (e.g. { "status": "active" }) or MongoDB-style operators (e.g. { "amount": { "$gt": 100 } })'
+          },
+          fields: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of field names to return (omit for all fields)"
+          },
+          orderBy: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                field: { type: "string" },
+                order: { type: "string", enum: ["asc", "desc"] }
+              }
+            },
+            description: 'Sort order (e.g. [{ "field": "created_at", "order": "desc" }])'
+          },
+          limit: {
+            type: "number",
+            description: `Maximum number of records to return (default ${DEFAULT_QUERY_LIMIT}, max ${MAX_QUERY_LIMIT})`
+          },
+          offset: {
+            type: "number",
+            description: "Number of records to skip for pagination"
+          }
+        },
+        required: ["objectName"],
+        additionalProperties: false
+      }
     };
-  }
-  async complete(prompt, options) {
-    return {
-      content: `[memory] ${prompt}`,
-      model: options?.model ?? "memory",
-      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+    GET_RECORD_TOOL = {
+      name: "get_record",
+      description: "Get a single record by its ID from a data object.",
+      parameters: {
+        type: "object",
+        properties: {
+          objectName: {
+            type: "string",
+            description: "The snake_case name of the object"
+          },
+          recordId: {
+            type: "string",
+            description: "The unique ID of the record"
+          },
+          fields: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of field names to return (omit for all fields)"
+          }
+        },
+        required: ["objectName", "recordId"],
+        additionalProperties: false
+      }
     };
-  }
-  async *streamChat(messages, _options) {
-    const result = await this.chat(messages);
-    const words = result.content.split(" ");
-    for (let i = 0; i < words.length; i++) {
-      const wordText = i === 0 ? words[i] : ` ${words[i]}`;
-      yield { type: "text-delta", id: `delta_${i}`, text: wordText };
-    }
-    yield {
-      type: "finish",
-      finishReason: "stop",
-      totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-      rawFinishReason: "stop"
+    AGGREGATE_DATA_TOOL = {
+      name: "aggregate_data",
+      description: "Perform aggregation/statistical operations on a data object. Supports count, sum, avg, min, max with optional groupBy and where filters.",
+      parameters: {
+        type: "object",
+        properties: {
+          objectName: {
+            type: "string",
+            description: "The snake_case name of the object to aggregate"
+          },
+          aggregations: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                function: {
+                  type: "string",
+                  enum: ["count", "sum", "avg", "min", "max", "count_distinct"],
+                  description: "Aggregation function"
+                },
+                field: {
+                  type: "string",
+                  description: "Field to aggregate (optional for count)"
+                },
+                alias: {
+                  type: "string",
+                  description: "Result column alias"
+                }
+              },
+              required: ["function", "alias"]
+            },
+            description: "Aggregation definitions"
+          },
+          groupBy: {
+            type: "array",
+            items: { type: "string" },
+            description: "Fields to group by"
+          },
+          where: {
+            type: "object",
+            description: "Filter conditions applied before aggregation"
+          }
+        },
+        required: ["objectName", "aggregations"],
+        additionalProperties: false
+      }
     };
+    DATA_TOOL_DEFINITIONS = [
+      QUERY_RECORDS_TOOL,
+      GET_RECORD_TOOL,
+      AGGREGATE_DATA_TOOL
+    ];
+    VALID_AGG_FUNCTIONS = /* @__PURE__ */ new Set([
+      "count",
+      "sum",
+      "avg",
+      "min",
+      "max",
+      "count_distinct"
+    ]);
   }
-  async embed(input) {
-    const texts = Array.isArray(input) ? input : [input];
-    return texts.map(() => [0, 0, 0]);
-  }
-  async listModels() {
-    return ["memory"];
+});
+
+// src/tools/create-object.tool.ts
+var import_ai, createObjectTool;
+var init_create_object_tool = __esm({
+  "src/tools/create-object.tool.ts"() {
+    "use strict";
+    import_ai = require("@objectstack/spec/ai");
+    createObjectTool = (0, import_ai.defineTool)({
+      name: "create_object",
+      label: "Create Object",
+      description: "Creates a new data object (table) with the specified name, label, and optional field definitions. Use this when the user wants to create a new entity, table, or data model.",
+      category: "data",
+      builtIn: true,
+      // NOTE: requiresConfirmation is intentionally false (default) because the
+      // server-side tool-call loop in AIService.chatWithTools/streamChatWithTools
+      // executes tool calls immediately without checking this flag.  The flag
+      // should only be set once server-side approval gating is implemented to
+      // avoid giving users a false sense of safety.
+      parameters: {
+        type: "object",
+        properties: {
+          name: {
+            type: "string",
+            description: "Machine name for the object (snake_case, e.g. project_task)"
+          },
+          label: {
+            type: "string",
+            description: "Human-readable display name (e.g. Project Task)"
+          },
+          fields: {
+            type: "array",
+            description: "Initial fields to create with the object",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string", description: "Field machine name (snake_case)" },
+                label: { type: "string", description: "Field display name" },
+                type: {
+                  type: "string",
+                  description: "Field data type",
+                  enum: ["text", "textarea", "number", "boolean", "date", "datetime", "select", "lookup", "formula", "autonumber"]
+                },
+                required: { type: "boolean", description: "Whether the field is required" }
+              },
+              required: ["name", "type"]
+            }
+          },
+          enableFeatures: {
+            type: "object",
+            description: "Object capability flags",
+            properties: {
+              trackHistory: { type: "boolean" },
+              apiEnabled: { type: "boolean" }
+            }
+          }
+        },
+        required: ["name", "label"],
+        additionalProperties: false
+      }
+    });
   }
-};
+});
 
-// src/tools/tool-registry.ts
-var ToolRegistry = class {
-  constructor() {
-    this.definitions = /* @__PURE__ */ new Map();
-    this.handlers = /* @__PURE__ */ new Map();
+// src/tools/add-field.tool.ts
+var import_ai2, addFieldTool;
+var init_add_field_tool = __esm({
+  "src/tools/add-field.tool.ts"() {
+    "use strict";
+    import_ai2 = require("@objectstack/spec/ai");
+    addFieldTool = (0, import_ai2.defineTool)({
+      name: "add_field",
+      label: "Add Field",
+      description: "Adds a new field (column) to an existing data object. Use this when the user wants to add a property, column, or attribute to a table.",
+      category: "data",
+      builtIn: true,
+      parameters: {
+        type: "object",
+        properties: {
+          objectName: {
+            type: "string",
+            description: "Target object machine name (snake_case)"
+          },
+          name: {
+            type: "string",
+            description: "Field machine name (snake_case, e.g. due_date)"
+          },
+          label: {
+            type: "string",
+            description: "Human-readable field label (e.g. Due Date)"
+          },
+          type: {
+            type: "string",
+            description: "Field data type",
+            enum: ["text", "textarea", "number", "boolean", "date", "datetime", "select", "lookup", "formula", "autonumber"]
+          },
+          required: {
+            type: "boolean",
+            description: "Whether the field is required"
+          },
+          defaultValue: {
+            description: "Default value for the field"
+          },
+          options: {
+            type: "array",
+            description: "Options for select/picklist fields",
+            items: {
+              type: "object",
+              properties: {
+                label: { type: "string" },
+                value: {
+                  type: "string",
+                  description: "Option machine identifier (lowercase snake_case, e.g. high_priority)",
+                  pattern: "^[a-z_][a-z0-9_]*$"
+                }
+              }
+            }
+          },
+          reference: {
+            type: "string",
+            description: "Referenced object name for lookup fields (snake_case, e.g. account)"
+          }
+        },
+        required: ["objectName", "name", "type"],
+        additionalProperties: false
+      }
+    });
   }
-  /**
-   * Register a tool with its definition and handler.
-   * @param definition - Tool definition (name, description, parameters schema)
-   * @param handler    - Async function that executes the tool
-   */
-  register(definition, handler) {
-    this.definitions.set(definition.name, definition);
-    this.handlers.set(definition.name, handler);
+});
+
+// src/tools/modify-field.tool.ts
+var import_ai3, modifyFieldTool;
+var init_modify_field_tool = __esm({
+  "src/tools/modify-field.tool.ts"() {
+    "use strict";
+    import_ai3 = require("@objectstack/spec/ai");
+    modifyFieldTool = (0, import_ai3.defineTool)({
+      name: "modify_field",
+      label: "Modify Field",
+      description: "Modifies an existing field definition (label, type, required, default value, etc.) on a data object. Use this when the user wants to change or reconfigure an existing column or attribute (not rename it).",
+      category: "data",
+      builtIn: true,
+      parameters: {
+        type: "object",
+        properties: {
+          objectName: {
+            type: "string",
+            description: "Target object machine name (snake_case)"
+          },
+          fieldName: {
+            type: "string",
+            description: "Existing field machine name to modify (snake_case)"
+          },
+          changes: {
+            type: "object",
+            description: "Field properties to update (partial patch)",
+            properties: {
+              label: { type: "string", description: "New display label" },
+              type: { type: "string", description: "New field type" },
+              required: { type: "boolean", description: "Update required constraint" },
+              defaultValue: { description: "New default value" }
+            }
+          }
+        },
+        required: ["objectName", "fieldName", "changes"],
+        additionalProperties: false
+      }
+    });
   }
-  /**
-   * Unregister a tool by name.
-   */
-  unregister(name) {
-    this.definitions.delete(name);
-    this.handlers.delete(name);
+});
+
+// src/tools/delete-field.tool.ts
+var import_ai4, deleteFieldTool;
+var init_delete_field_tool = __esm({
+  "src/tools/delete-field.tool.ts"() {
+    "use strict";
+    import_ai4 = require("@objectstack/spec/ai");
+    deleteFieldTool = (0, import_ai4.defineTool)({
+      name: "delete_field",
+      label: "Delete Field",
+      description: "Removes a field (column) from an existing data object. This is a destructive operation. Use this when the user explicitly wants to remove an attribute or column from a table.",
+      category: "data",
+      builtIn: true,
+      // NOTE: requiresConfirmation is intentionally false (default) because the
+      // server-side tool-call loop in AIService.chatWithTools/streamChatWithTools
+      // executes tool calls immediately without checking this flag.  The flag
+      // should only be set once server-side approval gating is implemented.
+      parameters: {
+        type: "object",
+        properties: {
+          objectName: {
+            type: "string",
+            description: "Target object machine name (snake_case)"
+          },
+          fieldName: {
+            type: "string",
+            description: "Field machine name to delete (snake_case)"
+          }
+        },
+        required: ["objectName", "fieldName"],
+        additionalProperties: false
+      }
+    });
   }
-  /**
-   * Check whether a tool is registered.
-   */
-  has(name) {
-    return this.definitions.has(name);
+});
+
+// src/tools/list-objects.tool.ts
+var import_ai5, listObjectsTool;
+var init_list_objects_tool = __esm({
+  "src/tools/list-objects.tool.ts"() {
+    "use strict";
+    import_ai5 = require("@objectstack/spec/ai");
+    listObjectsTool = (0, import_ai5.defineTool)({
+      name: "list_objects",
+      label: "List Objects",
+      description: "Lists all registered data objects (tables) in the current environment. Use this when the user wants to see what tables, entities, or data models are available.",
+      category: "data",
+      builtIn: true,
+      parameters: {
+        type: "object",
+        properties: {
+          filter: {
+            type: "string",
+            description: "Optional name or label substring to filter objects"
+          },
+          includeFields: {
+            type: "boolean",
+            description: "Whether to include field summaries for each object (default: false)"
+          }
+        },
+        additionalProperties: false
+      }
+    });
   }
-  /**
-   * Get the definition for a registered tool.
-   */
-  getDefinition(name) {
-    return this.definitions.get(name);
-  }
-  /**
-   * Return all registered tool definitions.
-   */
-  getAll() {
-    return Array.from(this.definitions.values());
-  }
-  /** Number of registered tools. */
-  get size() {
-    return this.definitions.size;
-  }
-  /** All registered tool names. */
-  names() {
-    return Array.from(this.definitions.keys());
+});
+
+// src/tools/describe-object.tool.ts
+var import_ai6, describeObjectTool;
+var init_describe_object_tool = __esm({
+  "src/tools/describe-object.tool.ts"() {
+    "use strict";
+    import_ai6 = require("@objectstack/spec/ai");
+    describeObjectTool = (0, import_ai6.defineTool)({
+      name: "describe_object",
+      label: "Describe Object",
+      description: "Returns the full schema details of a data object, including all fields, types, relationships, and configuration. Use this to understand the structure of a table before querying or modifying it.",
+      category: "data",
+      builtIn: true,
+      parameters: {
+        type: "object",
+        properties: {
+          objectName: {
+            type: "string",
+            description: "Object machine name to describe (snake_case)"
+          }
+        },
+        required: ["objectName"],
+        additionalProperties: false
+      }
+    });
   }
-  /**
-   * Execute a tool call and return the result.
-   */
-  async execute(toolCall) {
-    const handler = this.handlers.get(toolCall.toolName);
-    if (!handler) {
-      return {
-        type: "tool-result",
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        output: { type: "text", value: `Tool "${toolCall.toolName}" is not registered` },
-        isError: true
-      };
+});
+
+// src/tools/metadata-tools.ts
+var metadata_tools_exports = {};
+__export(metadata_tools_exports, {
+  METADATA_TOOL_DEFINITIONS: () => METADATA_TOOL_DEFINITIONS,
+  addFieldTool: () => addFieldTool,
+  createObjectTool: () => createObjectTool,
+  deleteFieldTool: () => deleteFieldTool,
+  describeObjectTool: () => describeObjectTool,
+  listObjectsTool: () => listObjectsTool,
+  modifyFieldTool: () => modifyFieldTool,
+  registerMetadataTools: () => registerMetadataTools
+});
+function isSnakeCase(value) {
+  return SNAKE_CASE_RE.test(value);
+}
+function createCreateObjectHandler(ctx) {
+  return async (args) => {
+    const { name, label, fields, enableFeatures } = args;
+    if (!name || !label) {
+      return JSON.stringify({ error: 'Both "name" and "label" are required' });
     }
-    try {
-      const args = typeof toolCall.input === "string" ? JSON.parse(toolCall.input) : toolCall.input ?? {};
-      const content = await handler(args);
-      return {
-        type: "tool-result",
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        output: { type: "text", value: content }
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        type: "tool-result",
-        toolCallId: toolCall.toolCallId,
-        toolName: toolCall.toolName,
-        output: { type: "text", value: message },
-        isError: true
-      };
+    if (!isSnakeCase(name)) {
+      return JSON.stringify({ error: `Invalid object name "${name}". Must be snake_case.` });
     }
-  }
-  /**
-   * Execute multiple tool calls in parallel.
-   */
-  async executeAll(toolCalls) {
-    return Promise.all(toolCalls.map((tc) => this.execute(tc)));
-  }
-  /**
-   * Clear all registered tools.
-   */
-  clear() {
-    this.definitions.clear();
-    this.handlers.clear();
-  }
-};
-
-// src/conversation/in-memory-conversation-service.ts
-var InMemoryConversationService = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-    this.counter = 0;
-  }
-  async create(options = {}) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `conv_${++this.counter}`;
-    const conversation = {
-      id,
-      title: options.title,
-      agentId: options.agentId,
-      userId: options.userId,
-      messages: [],
-      createdAt: now,
-      updatedAt: now,
-      metadata: options.metadata
+    const existing = await ctx.metadataService.getObject(name);
+    if (existing) {
+      return JSON.stringify({ error: `Object "${name}" already exists` });
+    }
+    const fieldMap = {};
+    if (fields && Array.isArray(fields)) {
+      const seenNames = /* @__PURE__ */ new Set();
+      for (const f of fields) {
+        if (!f.name) {
+          return JSON.stringify({ error: 'Each field must have a "name" property' });
+        }
+        if (!isSnakeCase(f.name)) {
+          return JSON.stringify({ error: `Invalid field name "${f.name}". Must be snake_case.` });
+        }
+        if (seenNames.has(f.name)) {
+          return JSON.stringify({ error: `Duplicate field name "${f.name}" in initial fields` });
+        }
+        seenNames.add(f.name);
+        fieldMap[f.name] = {
+          type: f.type,
+          ...f.label ? { label: f.label } : {},
+          ...f.required !== void 0 ? { required: f.required } : {}
+        };
+      }
+    }
+    const objectDef = {
+      name,
+      label,
+      ...Object.keys(fieldMap).length > 0 ? { fields: fieldMap } : {},
+      ...enableFeatures ? { enable: enableFeatures } : {}
     };
-    this.store.set(id, conversation);
-    return conversation;
-  }
-  async get(conversationId) {
-    return this.store.get(conversationId) ?? null;
-  }
-  async list(options = {}) {
-    let results = Array.from(this.store.values());
-    if (options.userId) {
-      results = results.filter((c) => c.userId === options.userId);
+    await ctx.metadataService.register("object", name, objectDef);
+    return JSON.stringify({
+      name,
+      label,
+      fieldCount: Object.keys(fieldMap).length
+    });
+  };
+}
+function createAddFieldHandler(ctx) {
+  return async (args) => {
+    const { objectName, name, label, type, required, defaultValue, options, reference } = args;
+    if (!objectName || !name || !type) {
+      return JSON.stringify({ error: '"objectName", "name", and "type" are required' });
     }
-    if (options.agentId) {
-      results = results.filter((c) => c.agentId === options.agentId);
+    if (!isSnakeCase(objectName)) {
+      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
     }
-    if (options.cursor) {
-      const idx = results.findIndex((c) => c.id === options.cursor);
-      if (idx >= 0) {
-        results = results.slice(idx + 1);
+    if (!isSnakeCase(name)) {
+      return JSON.stringify({ error: `Invalid field name "${name}". Must be snake_case.` });
+    }
+    if (reference && !isSnakeCase(reference)) {
+      return JSON.stringify({ error: `Invalid reference "${reference}". Must be a snake_case object name.` });
+    }
+    if (options && Array.isArray(options)) {
+      for (const opt of options) {
+        if (opt.value && !isSnakeCase(opt.value)) {
+          return JSON.stringify({ error: `Invalid option value "${opt.value}". Must be lowercase snake_case.` });
+        }
       }
     }
-    if (options.limit && options.limit > 0) {
-      results = results.slice(0, options.limit);
+    const objectDef = await ctx.metadataService.getObject(objectName);
+    if (!objectDef) {
+      return JSON.stringify({ error: `Object "${objectName}" not found` });
     }
-    return results;
-  }
-  async addMessage(conversationId, message) {
-    const conversation = this.store.get(conversationId);
-    if (!conversation) {
-      throw new Error(`Conversation "${conversationId}" not found`);
+    const def = objectDef;
+    if (def.fields && def.fields[name]) {
+      return JSON.stringify({ error: `Field "${name}" already exists on object "${objectName}"` });
     }
-    conversation.messages.push(message);
-    conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return conversation;
-  }
-  async delete(conversationId) {
-    this.store.delete(conversationId);
-  }
-  /** Total number of stored conversations. */
-  get size() {
-    return this.store.size;
-  }
-  /** Clear all conversations. */
-  clear() {
-    this.store.clear();
-    this.counter = 0;
-  }
-};
-
-// src/ai-service.ts
-function textDeltaPart(id, text) {
-  return { type: "text-delta", id, text };
-}
-function finishPart(result) {
-  return {
-    type: "finish",
-    finishReason: "stop",
-    totalUsage: result?.usage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
-    rawFinishReason: "stop"
+    const fieldDef = {
+      type,
+      ...label ? { label } : {},
+      ...required !== void 0 ? { required } : {},
+      ...defaultValue !== void 0 ? { defaultValue } : {},
+      ...options ? { options } : {},
+      ...reference ? { reference } : {}
+    };
+    const updatedFields = { ...def.fields ?? {}, [name]: fieldDef };
+    await ctx.metadataService.register("object", objectName, {
+      ...def,
+      fields: updatedFields
+    });
+    return JSON.stringify({
+      objectName,
+      fieldName: name,
+      fieldType: type
+    });
   };
 }
-var _AIService = class _AIService {
-  constructor(config = {}) {
-    this.adapter = config.adapter ?? new MemoryLLMAdapter();
-    this.logger = config.logger ?? (0, import_core.createLogger)({ level: "info", format: "pretty" });
-    this.toolRegistry = config.toolRegistry ?? new ToolRegistry();
-    this.conversationService = config.conversationService ?? new InMemoryConversationService();
-    this.logger.info(
-      `[AI] Service initialized with adapter="${this.adapter.name}", tools=${this.toolRegistry.size}`
-    );
-  }
-  /** The name of the active LLM adapter. */
-  get adapterName() {
-    return this.adapter.name;
-  }
-  // ── IAIService implementation ──────────────────────────────────
+function createModifyFieldHandler(ctx) {
+  return async (args) => {
+    const { objectName, fieldName, changes } = args;
+    if (!objectName || !fieldName || !changes) {
+      return JSON.stringify({ error: '"objectName", "fieldName", and "changes" are required' });
+    }
+    if (!isSnakeCase(objectName)) {
+      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
+    }
+    if (!isSnakeCase(fieldName)) {
+      return JSON.stringify({ error: `Invalid field name "${fieldName}". Must be snake_case.` });
+    }
+    const objectDef = await ctx.metadataService.getObject(objectName);
+    if (!objectDef) {
+      return JSON.stringify({ error: `Object "${objectName}" not found` });
+    }
+    const def = objectDef;
+    if (!def.fields || !def.fields[fieldName]) {
+      return JSON.stringify({ error: `Field "${fieldName}" not found on object "${objectName}"` });
+    }
+    const existingField = def.fields[fieldName];
+    const updatedField = { ...existingField, ...changes };
+    const updatedFields = { ...def.fields, [fieldName]: updatedField };
+    await ctx.metadataService.register("object", objectName, {
+      ...def,
+      fields: updatedFields
+    });
+    return JSON.stringify({
+      objectName,
+      fieldName,
+      updatedProperties: Object.keys(changes)
+    });
+  };
+}
+function createDeleteFieldHandler(ctx) {
+  return async (args) => {
+    const { objectName, fieldName } = args;
+    if (!objectName || !fieldName) {
+      return JSON.stringify({ error: '"objectName" and "fieldName" are required' });
+    }
+    if (!isSnakeCase(objectName)) {
+      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
+    }
+    if (!isSnakeCase(fieldName)) {
+      return JSON.stringify({ error: `Invalid field name "${fieldName}". Must be snake_case.` });
+    }
+    const objectDef = await ctx.metadataService.getObject(objectName);
+    if (!objectDef) {
+      return JSON.stringify({ error: `Object "${objectName}" not found` });
+    }
+    const def = objectDef;
+    if (!def.fields || !def.fields[fieldName]) {
+      return JSON.stringify({ error: `Field "${fieldName}" not found on object "${objectName}"` });
+    }
+    const { [fieldName]: _removed, ...remainingFields } = def.fields;
+    await ctx.metadataService.register("object", objectName, {
+      ...def,
+      fields: remainingFields
+    });
+    return JSON.stringify({
+      objectName,
+      fieldName,
+      success: true
+    });
+  };
+}
+function createListObjectsHandler(ctx) {
+  return async (args) => {
+    const { filter, includeFields } = args ?? {};
+    const objects = await ctx.metadataService.listObjects();
+    let result = objects.map((o) => {
+      const base = {
+        name: o.name,
+        label: o.label ?? o.name,
+        fieldCount: o.fields ? Object.keys(o.fields).length : 0
+      };
+      if (includeFields && o.fields) {
+        base.fields = Object.entries(o.fields).map(([key, f]) => ({
+          name: key,
+          type: f.type,
+          label: f.label ?? key
+        }));
+      }
+      return base;
+    });
+    if (filter) {
+      const lower = filter.toLowerCase();
+      result = result.filter(
+        (o) => o.name.toLowerCase().includes(lower) || o.label.toLowerCase().includes(lower)
+      );
+    }
+    return JSON.stringify({
+      objects: result,
+      totalCount: result.length
+    });
+  };
+}
+function createDescribeObjectHandler(ctx) {
+  return async (args) => {
+    const { objectName } = args;
+    if (!objectName) {
+      return JSON.stringify({ error: '"objectName" is required' });
+    }
+    if (!isSnakeCase(objectName)) {
+      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
+    }
+    const objectDef = await ctx.metadataService.getObject(objectName);
+    if (!objectDef) {
+      return JSON.stringify({ error: `Object "${objectName}" not found` });
+    }
+    const def = objectDef;
+    const fields = def.fields ?? {};
+    const fieldSummary = Object.entries(fields).map(([key, f]) => ({
+      name: key,
+      type: f.type,
+      label: f.label ?? key,
+      required: f.required ?? false,
+      ...f.reference ? { reference: f.reference } : {},
+      ...f.options ? { options: f.options } : {}
+    }));
+    return JSON.stringify({
+      name: def.name,
+      label: def.label ?? def.name,
+      fields: fieldSummary,
+      enableFeatures: def.enable ?? {}
+    });
+  };
+}
+function registerMetadataTools(registry, context) {
+  registry.register(createObjectTool, createCreateObjectHandler(context));
+  registry.register(addFieldTool, createAddFieldHandler(context));
+  registry.register(modifyFieldTool, createModifyFieldHandler(context));
+  registry.register(deleteFieldTool, createDeleteFieldHandler(context));
+  registry.register(listObjectsTool, createListObjectsHandler(context));
+  registry.register(describeObjectTool, createDescribeObjectHandler(context));
+}
+var METADATA_TOOL_DEFINITIONS, SNAKE_CASE_RE;
+var init_metadata_tools = __esm({
+  "src/tools/metadata-tools.ts"() {
+    "use strict";
+    init_create_object_tool();
+    init_add_field_tool();
+    init_modify_field_tool();
+    init_delete_field_tool();
+    init_list_objects_tool();
+    init_describe_object_tool();
+    init_create_object_tool();
+    init_add_field_tool();
+    init_modify_field_tool();
+    init_delete_field_tool();
+    init_list_objects_tool();
+    init_describe_object_tool();
+    METADATA_TOOL_DEFINITIONS = [
+      createObjectTool,
+      addFieldTool,
+      modifyFieldTool,
+      deleteFieldTool,
+      listObjectsTool,
+      describeObjectTool
+    ];
+    SNAKE_CASE_RE = /^[a-z_][a-z0-9_]*$/;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AIService: () => AIService,
+  AIServicePlugin: () => AIServicePlugin,
+  AgentRuntime: () => AgentRuntime,
+  AiConversationObject: () => AiConversationObject,
+  AiMessageObject: () => AiMessageObject,
+  DATA_CHAT_AGENT: () => DATA_CHAT_AGENT,
+  DATA_TOOL_DEFINITIONS: () => DATA_TOOL_DEFINITIONS,
+  InMemoryConversationService: () => InMemoryConversationService,
+  METADATA_ASSISTANT_AGENT: () => METADATA_ASSISTANT_AGENT,
+  METADATA_TOOL_DEFINITIONS: () => METADATA_TOOL_DEFINITIONS,
+  MemoryLLMAdapter: () => MemoryLLMAdapter,
+  ObjectQLConversationService: () => ObjectQLConversationService,
+  ToolRegistry: () => ToolRegistry,
+  VercelLLMAdapter: () => VercelLLMAdapter,
+  addFieldTool: () => addFieldTool,
+  buildAIRoutes: () => buildAIRoutes,
+  buildAgentRoutes: () => buildAgentRoutes,
+  buildToolRoutes: () => buildToolRoutes,
+  createObjectTool: () => createObjectTool,
+  deleteFieldTool: () => deleteFieldTool,
+  describeObjectTool: () => describeObjectTool,
+  encodeStreamPart: () => encodeStreamPart,
+  encodeVercelDataStream: () => encodeVercelDataStream,
+  listObjectsTool: () => listObjectsTool,
+  modifyFieldTool: () => modifyFieldTool,
+  registerDataTools: () => registerDataTools,
+  registerMetadataTools: () => registerMetadataTools
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ai-service.ts
+var import_core = require("@objectstack/core");
+
+// src/adapters/memory-adapter.ts
+var MemoryLLMAdapter = class {
+  constructor() {
+    this.name = "memory";
+  }
   async chat(messages, options) {
-    this.logger.debug("[AI] chat", { messageCount: messages.length, model: options?.model });
-    return this.adapter.chat(messages, options);
+    const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
+    const userContent = lastUserMessage?.content;
+    const text = typeof userContent === "string" ? userContent : "(complex content)";
+    const content = lastUserMessage ? `[memory] ${text}` : "[memory] (no user message)";
+    return {
+      content,
+      model: options?.model ?? "memory",
+      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+    };
   }
   async complete(prompt, options) {
-    this.logger.debug("[AI] complete", { promptLength: prompt.length, model: options?.model });
-    return this.adapter.complete(prompt, options);
+    return {
+      content: `[memory] ${prompt}`,
+      model: options?.model ?? "memory",
+      usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 }
+    };
   }
-  async *streamChat(messages, options) {
-    this.logger.debug("[AI] streamChat", { messageCount: messages.length, model: options?.model });
-    if (!this.adapter.streamChat) {
-      const result = await this.adapter.chat(messages, options);
-      yield textDeltaPart("fallback", result.content);
-      yield finishPart(result);
-      return;
+  async *streamChat(messages, _options) {
+    const result = await this.chat(messages);
+    const words = result.content.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      const wordText = i === 0 ? words[i] : ` ${words[i]}`;
+      yield { type: "text-delta", id: `delta_${i}`, text: wordText };
     }
-    yield* this.adapter.streamChat(messages, options);
+    yield {
+      type: "finish",
+      finishReason: "stop",
+      totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      rawFinishReason: "stop"
+    };
   }
-  async embed(input, model) {
-    if (!this.adapter.embed) {
-      throw new Error(`[AI] Adapter "${this.adapter.name}" does not support embeddings`);
-    }
-    return this.adapter.embed(input, model);
+  async embed(input) {
+    const texts = Array.isArray(input) ? input : [input];
+    return texts.map(() => [0, 0, 0]);
   }
   async listModels() {
-    if (!this.adapter.listModels) {
-      return [];
-    }
-    return this.adapter.listModels();
+    return ["memory"];
   }
-  /** Extract the text value from a ToolExecutionResult's output. */
-  static extractOutputText(tr) {
-    return tr.output && typeof tr.output === "object" && "value" in tr.output ? String(tr.output.value) : "unknown error";
+};
+
+// src/tools/tool-registry.ts
+var ToolRegistry = class {
+  constructor() {
+    this.definitions = /* @__PURE__ */ new Map();
+    this.handlers = /* @__PURE__ */ new Map();
   }
   /**
-   * Chat with automatic tool call resolution.
-   *
-   * 1. Merges registered tool definitions into `options.tools`.
-   * 2. Calls the LLM adapter.
-   * 3. If the response contains `toolCalls`, executes them via the
-   *    {@link ToolRegistry}, appends tool results as `role: 'tool'`
-   *    messages, and loops back to step 2.
-   * 4. Repeats until the model produces a final text response or the
-   *    maximum number of iterations (`maxIterations`) is reached.
+   * Register a tool with its definition and handler.
+   * @param definition - Tool definition (name, description, parameters schema)
+   * @param handler    - Async function that executes the tool
    */
-  async chatWithTools(messages, options) {
-    const { maxIterations: maxIter, onToolError, ...restOptions } = options ?? {};
-    const maxIterations = maxIter ?? _AIService.DEFAULT_MAX_ITERATIONS;
-    const registeredTools = this.toolRegistry.getAll();
-    const mergedTools = [
-      ...registeredTools,
-      ...restOptions.tools ?? []
+  register(definition, handler) {
+    this.definitions.set(definition.name, definition);
+    this.handlers.set(definition.name, handler);
+  }
+  /**
+   * Unregister a tool by name.
+   */
+  unregister(name) {
+    this.definitions.delete(name);
+    this.handlers.delete(name);
+  }
+  /**
+   * Check whether a tool is registered.
+   */
+  has(name) {
+    return this.definitions.has(name);
+  }
+  /**
+   * Get the definition for a registered tool.
+   */
+  getDefinition(name) {
+    return this.definitions.get(name);
+  }
+  /**
+   * Return all registered tool definitions.
+   */
+  getAll() {
+    return Array.from(this.definitions.values());
+  }
+  /** Number of registered tools. */
+  get size() {
+    return this.definitions.size;
+  }
+  /** All registered tool names. */
+  names() {
+    return Array.from(this.definitions.keys());
+  }
+  /**
+   * Execute a tool call and return the result.
+   */
+  async execute(toolCall) {
+    const handler = this.handlers.get(toolCall.toolName);
+    if (!handler) {
+      return {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: { type: "text", value: `Tool "${toolCall.toolName}" is not registered` },
+        isError: true
+      };
+    }
+    try {
+      const args = typeof toolCall.input === "string" ? JSON.parse(toolCall.input) : toolCall.input ?? {};
+      const content = await handler(args);
+      return {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: { type: "text", value: content }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: { type: "text", value: message },
+        isError: true
+      };
+    }
+  }
+  /**
+   * Execute multiple tool calls in parallel.
+   */
+  async executeAll(toolCalls) {
+    return Promise.all(toolCalls.map((tc) => this.execute(tc)));
+  }
+  /**
+   * Clear all registered tools.
+   */
+  clear() {
+    this.definitions.clear();
+    this.handlers.clear();
+  }
+};
+
+// src/conversation/in-memory-conversation-service.ts
+var InMemoryConversationService = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+    this.counter = 0;
+  }
+  async create(options = {}) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = `conv_${++this.counter}`;
+    const conversation = {
+      id,
+      title: options.title,
+      agentId: options.agentId,
+      userId: options.userId,
+      messages: [],
+      createdAt: now,
+      updatedAt: now,
+      metadata: options.metadata
+    };
+    this.store.set(id, conversation);
+    return conversation;
+  }
+  async get(conversationId) {
+    return this.store.get(conversationId) ?? null;
+  }
+  async list(options = {}) {
+    let results = Array.from(this.store.values());
+    if (options.userId) {
+      results = results.filter((c) => c.userId === options.userId);
+    }
+    if (options.agentId) {
+      results = results.filter((c) => c.agentId === options.agentId);
+    }
+    if (options.cursor) {
+      const idx = results.findIndex((c) => c.id === options.cursor);
+      if (idx >= 0) {
+        results = results.slice(idx + 1);
+      }
+    }
+    if (options.limit && options.limit > 0) {
+      results = results.slice(0, options.limit);
+    }
+    return results;
+  }
+  async addMessage(conversationId, message) {
+    const conversation = this.store.get(conversationId);
+    if (!conversation) {
+      throw new Error(`Conversation "${conversationId}" not found`);
+    }
+    conversation.messages.push(message);
+    conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return conversation;
+  }
+  async delete(conversationId) {
+    this.store.delete(conversationId);
+  }
+  /** Total number of stored conversations. */
+  get size() {
+    return this.store.size;
+  }
+  /** Clear all conversations. */
+  clear() {
+    this.store.clear();
+    this.counter = 0;
+  }
+};
+
+// src/ai-service.ts
+function textDeltaPart(id, text) {
+  return { type: "text-delta", id, text };
+}
+function finishPart(result) {
+  return {
+    type: "finish",
+    finishReason: "stop",
+    totalUsage: result?.usage ?? { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+    rawFinishReason: "stop"
+  };
+}
+var _AIService = class _AIService {
+  constructor(config = {}) {
+    this.adapter = config.adapter ?? new MemoryLLMAdapter();
+    this.logger = config.logger ?? (0, import_core.createLogger)({ level: "info", format: "pretty" });
+    this.toolRegistry = config.toolRegistry ?? new ToolRegistry();
+    this.conversationService = config.conversationService ?? new InMemoryConversationService();
+    this.logger.info(
+      `[AI] Service initialized with adapter="${this.adapter.name}", tools=${this.toolRegistry.size}`
+    );
+  }
+  /** The name of the active LLM adapter. */
+  get adapterName() {
+    return this.adapter.name;
+  }
+  // ── IAIService implementation ──────────────────────────────────
+  async chat(messages, options) {
+    this.logger.debug("[AI] chat", { messageCount: messages.length, model: options?.model });
+    return this.adapter.chat(messages, options);
+  }
+  async complete(prompt, options) {
+    this.logger.debug("[AI] complete", { promptLength: prompt.length, model: options?.model });
+    return this.adapter.complete(prompt, options);
+  }
+  async *streamChat(messages, options) {
+    this.logger.debug("[AI] streamChat", { messageCount: messages.length, model: options?.model });
+    if (!this.adapter.streamChat) {
+      const result = await this.adapter.chat(messages, options);
+      yield textDeltaPart("fallback", result.content);
+      yield finishPart(result);
+      return;
+    }
+    yield* this.adapter.streamChat(messages, options);
+  }
+  async embed(input, model) {
+    if (!this.adapter.embed) {
+      throw new Error(`[AI] Adapter "${this.adapter.name}" does not support embeddings`);
+    }
+    return this.adapter.embed(input, model);
+  }
+  async listModels() {
+    if (!this.adapter.listModels) {
+      return [];
+    }
+    return this.adapter.listModels();
+  }
+  /** Extract the text value from a ToolExecutionResult's output. */
+  static extractOutputText(tr) {
+    return tr.output && typeof tr.output === "object" && "value" in tr.output ? String(tr.output.value) : "unknown error";
+  }
+  /**
+   * Chat with automatic tool call resolution.
+   *
+   * 1. Merges registered tool definitions into `options.tools`.
+   * 2. Calls the LLM adapter.
+   * 3. If the response contains `toolCalls`, executes them via the
+   *    {@link ToolRegistry}, appends tool results as `role: 'tool'`
+   *    messages, and loops back to step 2.
+   * 4. Repeats until the model produces a final text response or the
+   *    maximum number of iterations (`maxIterations`) is reached.
+   */
+  async chatWithTools(messages, options) {
+    const { maxIterations: maxIter, onToolError, ...restOptions } = options ?? {};
+    const maxIterations = maxIter ?? _AIService.DEFAULT_MAX_ITERATIONS;
+    const registeredTools = this.toolRegistry.getAll();
+    const mergedTools = [
+      ...registeredTools,
+      ...restOptions.tools ?? []
     ];
     const chatOptions = {
       ...restOptions,
@@ -462,6 +1212,12 @@ var _AIService = class _AIService {
             }
           }
         }
+        yield {
+          type: "tool-result",
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName,
+          output: tr.output
+        };
         conversation.push({
           role: "tool",
           content: [tr]
@@ -493,6 +1249,10 @@ function sse(data) {
 
 `;
 }
+function dataStreamLine(prefix, data) {
+  return `${prefix}:${JSON.stringify(data)}
+`;
+}
 function encodeStreamPart(part) {
   switch (part.type) {
     case "text-delta":
@@ -527,8 +1287,20 @@ function encodeStreamPart(part) {
         type: "error",
         errorText: String(part.error)
       });
+    // Handle reasoning/thinking streams (DeepSeek R1, o1-style models)
+    // Use 'g:' prefix for reasoning content per Vercel AI SDK protocol
+    case "reasoning-start":
+      return dataStreamLine("g", { text: "" });
+    case "reasoning-delta":
+      return dataStreamLine("g", { text: part.text });
+    case "reasoning-end":
+      return "";
+    // No specific end marker needed for reasoning
     // finish-step and finish are handled by the generator, not here
     default:
+      if (part.type?.startsWith("step-")) {
+        return sse(part);
+      }
       return "";
   }
 }
@@ -562,8 +1334,7 @@ async function* encodeVercelDataStream(events) {
   yield "data: [DONE]\n\n";
 }
 
-// src/routes/ai-routes.ts
-var VALID_ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "tool"]);
+// src/routes/message-utils.ts
 function normalizeMessage(raw) {
   const role = raw.role;
   if (typeof raw.content === "string") {
@@ -580,14 +1351,7 @@ function normalizeMessage(raw) {
   }
   return { role, content: "" };
 }
-function validateMessage(raw) {
-  if (typeof raw !== "object" || raw === null) {
-    return "each message must be an object";
-  }
-  const msg = raw;
-  if (typeof msg.role !== "string" || !VALID_ROLES.has(msg.role)) {
-    return `message.role must be one of ${[...VALID_ROLES].map((r) => `"${r}"`).join(", ")}`;
-  }
+function validateMessageContent(msg, opts) {
   const content = msg.content;
   if (Array.isArray(msg.parts)) {
     return null;
@@ -610,20 +1374,32 @@ function validateMessage(raw) {
     }
     return null;
   }
-  if (content === null || content === void 0) {
-    if (msg.role === "assistant" || msg.role === "tool") {
-      return null;
-    }
+  if ((content === null || content === void 0) && opts?.allowEmptyContent) {
+    return null;
   }
   return "message.content must be a string, an array, or include parts";
 }
-function buildAIRoutes(aiService, conversationService, logger) {
-  return [
-    // ── Chat ────────────────────────────────────────────────────
-    //
-    // Dual-mode endpoint compatible with both the legacy ObjectStack
-    // format (`{ messages, options }`) and the Vercel AI SDK useChat
-    // flat format (`{ messages, system, model, stream, … }`).
+
+// src/routes/ai-routes.ts
+var VALID_ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "tool"]);
+function validateMessage(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return "each message must be an object";
+  }
+  const msg = raw;
+  if (typeof msg.role !== "string" || !VALID_ROLES.has(msg.role)) {
+    return `message.role must be one of ${[...VALID_ROLES].map((r) => `"${r}"`).join(", ")}`;
+  }
+  const allowEmpty = msg.role === "assistant" || msg.role === "tool";
+  return validateMessageContent(msg, { allowEmptyContent: allowEmpty });
+}
+function buildAIRoutes(aiService, conversationService, logger) {
+  return [
+    // ── Chat ────────────────────────────────────────────────────
+    //
+    // Dual-mode endpoint compatible with both the legacy ObjectStack
+    // format (`{ messages, options }`) and the Vercel AI SDK useChat
+    // flat format (`{ messages, system, model, stream, … }`).
     //
     // Behaviour:
     //   • `stream !== false` → Vercel Data Stream Protocol (SSE)
@@ -705,1358 +1481,764 @@ function buildAIRoutes(aiService, conversationService, logger) {
       handler: async (req) => {
         const { messages, options } = req.body ?? {};
         if (!Array.isArray(messages) || messages.length === 0) {
-          return { status: 400, body: { error: "messages array is required" } };
-        }
-        for (const msg of messages) {
-          const err = validateMessage(msg);
-          if (err) return { status: 400, body: { error: err } };
-        }
-        try {
-          if (!aiService.streamChat) {
-            return { status: 501, body: { error: "Streaming is not supported by the configured AI service" } };
-          }
-          const events = aiService.streamChat(messages.map((m) => normalizeMessage(m)), options);
-          return { status: 200, stream: true, events };
-        } catch (err) {
-          logger.error("[AI Route] /chat/stream error", err instanceof Error ? err : void 0);
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    },
-    // ── Complete ────────────────────────────────────────────────
-    {
-      method: "POST",
-      path: "/api/v1/ai/complete",
-      description: "Text completion",
-      auth: true,
-      permissions: ["ai:complete"],
-      handler: async (req) => {
-        const { prompt, options } = req.body ?? {};
-        if (!prompt || typeof prompt !== "string") {
-          return { status: 400, body: { error: "prompt string is required" } };
-        }
-        try {
-          const result = await aiService.complete(prompt, options);
-          return { status: 200, body: result };
-        } catch (err) {
-          logger.error("[AI Route] /complete error", err instanceof Error ? err : void 0);
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    },
-    // ── Models ──────────────────────────────────────────────────
-    {
-      method: "GET",
-      path: "/api/v1/ai/models",
-      description: "List available models",
-      auth: true,
-      permissions: ["ai:read"],
-      handler: async () => {
-        try {
-          const models = aiService.listModels ? await aiService.listModels() : [];
-          return { status: 200, body: { models } };
-        } catch (err) {
-          logger.error("[AI Route] /models error", err instanceof Error ? err : void 0);
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    },
-    // ── Conversations ──────────────────────────────────────────
-    {
-      method: "POST",
-      path: "/api/v1/ai/conversations",
-      description: "Create a conversation",
-      auth: true,
-      permissions: ["ai:conversations"],
-      handler: async (req) => {
-        try {
-          if (req.body !== void 0 && req.body !== null && (typeof req.body !== "object" || Array.isArray(req.body))) {
-            return { status: 400, body: { error: "Invalid request payload" } };
-          }
-          const options = { ...req.body ?? {} };
-          if (req.user?.userId) {
-            options.userId = req.user.userId;
-          }
-          const conversation = await conversationService.create(options);
-          return { status: 201, body: conversation };
-        } catch (err) {
-          logger.error("[AI Route] POST /conversations error", err instanceof Error ? err : void 0);
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    },
-    {
-      method: "GET",
-      path: "/api/v1/ai/conversations",
-      description: "List conversations",
-      auth: true,
-      permissions: ["ai:conversations"],
-      handler: async (req) => {
-        try {
-          const rawQuery = req.query ?? {};
-          const options = { ...rawQuery };
-          if (typeof rawQuery.limit === "string") {
-            const parsedLimit = Number(rawQuery.limit);
-            if (!Number.isFinite(parsedLimit) || parsedLimit <= 0 || !Number.isInteger(parsedLimit)) {
-              return { status: 400, body: { error: "Invalid limit parameter" } };
-            }
-            options.limit = parsedLimit;
-          }
-          if (req.user?.userId) {
-            options.userId = req.user.userId;
-          }
-          const conversations = await conversationService.list(options);
-          return { status: 200, body: { conversations } };
-        } catch (err) {
-          logger.error("[AI Route] GET /conversations error", err instanceof Error ? err : void 0);
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    },
-    {
-      method: "POST",
-      path: "/api/v1/ai/conversations/:id/messages",
-      description: "Add message to a conversation",
-      auth: true,
-      permissions: ["ai:conversations"],
-      handler: async (req) => {
-        const id = req.params?.id;
-        if (!id) {
-          return { status: 400, body: { error: "conversation id is required" } };
-        }
-        const message = req.body;
-        const validationError = validateMessage(message);
-        if (validationError) {
-          return { status: 400, body: { error: validationError } };
-        }
-        try {
-          if (req.user?.userId) {
-            const existing = await conversationService.get(id);
-            if (!existing) {
-              return { status: 404, body: { error: `Conversation "${id}" not found` } };
-            }
-            if (existing.userId && existing.userId !== req.user.userId) {
-              return { status: 403, body: { error: "You do not have access to this conversation" } };
-            }
-          }
-          const conversation = await conversationService.addMessage(id, message);
-          return { status: 200, body: conversation };
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          if (msg.includes("not found")) {
-            return { status: 404, body: { error: msg } };
-          }
-          logger.error("[AI Route] POST /conversations/:id/messages error", err instanceof Error ? err : void 0);
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    },
-    {
-      method: "DELETE",
-      path: "/api/v1/ai/conversations/:id",
-      description: "Delete a conversation",
-      auth: true,
-      permissions: ["ai:conversations"],
-      handler: async (req) => {
-        const id = req.params?.id;
-        if (!id) {
-          return { status: 400, body: { error: "conversation id is required" } };
-        }
-        try {
-          if (req.user?.userId) {
-            const existing = await conversationService.get(id);
-            if (!existing) {
-              return { status: 404, body: { error: `Conversation "${id}" not found` } };
-            }
-            if (existing.userId && existing.userId !== req.user.userId) {
-              return { status: 403, body: { error: "You do not have access to this conversation" } };
-            }
-          }
-          await conversationService.delete(id);
-          return { status: 204 };
-        } catch (err) {
-          logger.error("[AI Route] DELETE /conversations/:id error", err instanceof Error ? err : void 0);
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    }
-  ];
-}
-
-// src/routes/agent-routes.ts
-var ALLOWED_AGENT_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
-function validateAgentMessage(raw) {
-  if (typeof raw !== "object" || raw === null) {
-    return "each message must be an object";
-  }
-  const msg = raw;
-  if (typeof msg.role !== "string" || !ALLOWED_AGENT_ROLES.has(msg.role)) {
-    return `message.role must be one of ${[...ALLOWED_AGENT_ROLES].map((r) => `"${r}"`).join(", ")} for agent chat`;
-  }
-  if (typeof msg.content !== "string") {
-    return "message.content must be a string";
-  }
-  return null;
-}
-function buildAgentRoutes(aiService, agentRuntime, logger) {
-  return [
-    // ── List active agents ──────────────────────────────────────
-    {
-      method: "GET",
-      path: "/api/v1/ai/agents",
-      description: "List all active AI agents",
-      auth: true,
-      permissions: ["ai:chat"],
-      handler: async () => {
-        try {
-          const agents = await agentRuntime.listAgents();
-          return { status: 200, body: { agents } };
-        } catch (err) {
-          logger.error(
-            "[AI Route] /agents list error",
-            err instanceof Error ? err : void 0
-          );
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    },
-    // ── Chat with a specific agent ──────────────────────────────
-    {
-      method: "POST",
-      path: "/api/v1/ai/agents/:agentName/chat",
-      description: "Chat with a specific AI agent",
-      auth: true,
-      permissions: ["ai:chat", "ai:agents"],
-      handler: async (req) => {
-        const agentName = req.params?.agentName;
-        if (!agentName) {
-          return { status: 400, body: { error: "agentName parameter is required" } };
-        }
-        const {
-          messages: rawMessages,
-          context: chatContext,
-          options: extraOptions
-        } = req.body ?? {};
-        if (!Array.isArray(rawMessages) || rawMessages.length === 0) {
-          return { status: 400, body: { error: "messages array is required" } };
-        }
-        for (const msg of rawMessages) {
-          const err = validateAgentMessage(msg);
-          if (err) return { status: 400, body: { error: err } };
-        }
-        const agent = await agentRuntime.loadAgent(agentName);
-        if (!agent) {
-          return { status: 404, body: { error: `Agent "${agentName}" not found` } };
-        }
-        if (!agent.active) {
-          return { status: 403, body: { error: `Agent "${agentName}" is not active` } };
-        }
-        try {
-          const systemMessages = agentRuntime.buildSystemMessages(agent, chatContext);
-          const agentOptions = agentRuntime.buildRequestOptions(
-            agent,
-            aiService.toolRegistry.getAll()
-          );
-          const safeOverrides = {};
-          if (extraOptions) {
-            const ALLOWED_KEYS = /* @__PURE__ */ new Set(["temperature", "maxTokens", "stop"]);
-            for (const key of Object.keys(extraOptions)) {
-              if (ALLOWED_KEYS.has(key)) {
-                safeOverrides[key] = extraOptions[key];
-              }
-            }
-          }
-          const mergedOptions = { ...agentOptions, ...safeOverrides };
-          const fullMessages = [
-            ...systemMessages,
-            ...rawMessages
-          ];
-          const result = await aiService.chatWithTools(fullMessages, {
-            ...mergedOptions,
-            maxIterations: agent.planning?.maxIterations
-          });
-          return { status: 200, body: result };
-        } catch (err) {
-          logger.error(
-            "[AI Route] /agents/:agentName/chat error",
-            err instanceof Error ? err : void 0
-          );
-          return { status: 500, body: { error: "Internal AI service error" } };
-        }
-      }
-    }
-  ];
-}
-
-// src/conversation/objectql-conversation-service.ts
-var import_node_crypto = require("crypto");
-var CONVERSATIONS_OBJECT = "ai_conversations";
-var MESSAGES_OBJECT = "ai_messages";
-var CONVERSATION_ORDER = [
-  { field: "created_at", order: "asc" },
-  { field: "id", order: "asc" }
-];
-var MESSAGE_ORDER = [
-  { field: "created_at", order: "asc" },
-  { field: "id", order: "asc" }
-];
-var ObjectQLConversationService = class {
-  constructor(engine) {
-    this.engine = engine;
-  }
-  async create(options = {}) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const id = `conv_${(0, import_node_crypto.randomUUID)()}`;
-    const record = {
-      id,
-      title: options.title ?? null,
-      agent_id: options.agentId ?? null,
-      user_id: options.userId ?? null,
-      metadata: options.metadata ? JSON.stringify(options.metadata) : null,
-      created_at: now,
-      updated_at: now
-    };
-    await this.engine.insert(CONVERSATIONS_OBJECT, record);
-    return {
-      id,
-      title: options.title,
-      agentId: options.agentId,
-      userId: options.userId,
-      messages: [],
-      createdAt: now,
-      updatedAt: now,
-      metadata: options.metadata
-    };
-  }
-  async get(conversationId) {
-    const row = await this.engine.findOne(CONVERSATIONS_OBJECT, {
-      where: { id: conversationId }
-    });
-    if (!row) return null;
-    const messages = await this.engine.find(MESSAGES_OBJECT, {
-      where: { conversation_id: conversationId },
-      orderBy: MESSAGE_ORDER
-    });
-    return this.toConversation(row, messages);
-  }
-  async list(options = {}) {
-    const where = {};
-    if (options.userId) where.user_id = options.userId;
-    if (options.agentId) where.agent_id = options.agentId;
-    if (options.cursor) {
-      const cursorRow = await this.engine.findOne(CONVERSATIONS_OBJECT, {
-        where: { id: options.cursor },
-        fields: ["created_at", "id"]
-      });
-      if (cursorRow) {
-        where.$or = [
-          { created_at: { $gt: cursorRow.created_at } },
-          { created_at: cursorRow.created_at, id: { $gt: cursorRow.id } }
-        ];
-      }
-    }
-    const rows = await this.engine.find(CONVERSATIONS_OBJECT, {
-      where: Object.keys(where).length > 0 ? where : void 0,
-      orderBy: CONVERSATION_ORDER,
-      limit: options.limit && options.limit > 0 ? options.limit : void 0
-    });
-    const conversations = await Promise.all(
-      rows.map(async (row) => {
-        const messages = await this.engine.find(MESSAGES_OBJECT, {
-          where: { conversation_id: row.id },
-          orderBy: MESSAGE_ORDER
-        });
-        return this.toConversation(row, messages);
-      })
-    );
-    return conversations;
-  }
-  async addMessage(conversationId, message) {
-    const row = await this.engine.findOne(CONVERSATIONS_OBJECT, {
-      where: { id: conversationId }
-    });
-    if (!row) {
-      throw new Error(`Conversation "${conversationId}" not found`);
-    }
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const msgId = `msg_${(0, import_node_crypto.randomUUID)()}`;
-    let contentStr;
-    let toolCallsJson = null;
-    let toolCallId = null;
-    if (message.role === "system" || message.role === "user") {
-      contentStr = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
-    } else if (message.role === "assistant") {
-      if (typeof message.content === "string") {
-        contentStr = message.content;
-      } else {
-        const parts = message.content;
-        const textParts = parts.filter((p) => p.type === "text").map((p) => p.text);
-        const toolCalls = parts.filter((p) => p.type === "tool-call");
-        contentStr = textParts.join("");
-        if (toolCalls.length > 0) toolCallsJson = JSON.stringify(toolCalls);
-      }
-    } else if (message.role === "tool") {
-      contentStr = JSON.stringify(message.content);
-      const firstResult = Array.isArray(message.content) ? message.content[0] : void 0;
-      if (firstResult && "toolCallId" in firstResult) toolCallId = firstResult.toolCallId;
-    } else {
-      contentStr = "";
-    }
-    await this.engine.insert(MESSAGES_OBJECT, {
-      id: msgId,
-      conversation_id: conversationId,
-      role: message.role,
-      content: contentStr,
-      tool_calls: toolCallsJson,
-      tool_call_id: toolCallId,
-      created_at: now
-    });
-    await this.engine.update(CONVERSATIONS_OBJECT, { id: conversationId, updated_at: now }, {
-      where: { id: conversationId }
-    });
-    return await this.get(conversationId);
-  }
-  async delete(conversationId) {
-    await this.engine.delete(MESSAGES_OBJECT, {
-      where: { conversation_id: conversationId },
-      multi: true
-    });
-    await this.engine.delete(CONVERSATIONS_OBJECT, {
-      where: { id: conversationId }
-    });
-  }
-  // ── Private helpers ──────────────────────────────────────────────
-  /**
-   * Safely parse a JSON string, returning `undefined` on failure.
-   */
-  safeParse(value, fallback) {
-    if (!value) return void 0;
-    try {
-      return JSON.parse(value);
-    } catch {
-      return fallback;
-    }
-  }
-  /**
-   * Map a database row + message rows to an AIConversation.
-   */
-  toConversation(row, messageRows) {
-    return {
-      id: row.id,
-      title: row.title ?? void 0,
-      agentId: row.agent_id ?? void 0,
-      userId: row.user_id ?? void 0,
-      messages: messageRows.map((m) => this.toMessage(m)),
-      createdAt: row.created_at,
-      updatedAt: row.updated_at,
-      metadata: this.safeParse(row.metadata)
-    };
-  }
-  /**
-   * Map a database row to a ModelMessage.
-   */
-  toMessage(row) {
-    switch (row.role) {
-      case "system":
-        return { role: "system", content: row.content };
-      case "user":
-        return { role: "user", content: row.content };
-      case "assistant": {
-        const toolCalls = this.safeParse(row.tool_calls);
-        if (toolCalls && toolCalls.length > 0) {
-          const content = [];
-          if (row.content) content.push({ type: "text", text: row.content });
-          content.push(...toolCalls);
-          return { role: "assistant", content };
-        }
-        return { role: "assistant", content: row.content };
-      }
-      case "tool": {
-        const toolResults = this.safeParse(row.content);
-        if (toolResults && toolResults.length > 0 && toolResults[0]?.type === "tool-result") {
-          return { role: "tool", content: toolResults };
-        }
-        return {
-          role: "tool",
-          content: [{
-            type: "tool-result",
-            toolCallId: row.tool_call_id ?? "",
-            toolName: "unknown",
-            output: { type: "text", value: row.content }
-          }]
-        };
-      }
-      default:
-        return { role: "user", content: row.content };
-    }
-  }
-};
-
-// src/objects/ai-conversation.object.ts
-var import_data = require("@objectstack/spec/data");
-var AiConversationObject = import_data.ObjectSchema.create({
-  namespace: "ai",
-  name: "conversations",
-  label: "AI Conversation",
-  pluralLabel: "AI Conversations",
-  icon: "message-square",
-  isSystem: true,
-  description: "Persistent AI conversation metadata",
-  fields: {
-    id: import_data.Field.text({
-      label: "Conversation ID",
-      required: true,
-      readonly: true
-    }),
-    title: import_data.Field.text({
-      label: "Title",
-      required: false,
-      maxLength: 500,
-      description: "Conversation title or summary"
-    }),
-    agent_id: import_data.Field.text({
-      label: "Agent ID",
-      required: false,
-      maxLength: 255,
-      description: "Associated AI agent identifier"
-    }),
-    user_id: import_data.Field.text({
-      label: "User ID",
-      required: false,
-      maxLength: 255,
-      description: "User who owns the conversation"
-    }),
-    metadata: import_data.Field.textarea({
-      label: "Metadata",
-      required: false,
-      description: "JSON-serialized conversation metadata"
-    }),
-    created_at: import_data.Field.datetime({
-      label: "Created At",
-      required: true,
-      defaultValue: "NOW()",
-      readonly: true
-    }),
-    updated_at: import_data.Field.datetime({
-      label: "Updated At",
-      required: true,
-      defaultValue: "NOW()",
-      readonly: true
-    })
-  },
-  indexes: [
-    { fields: ["user_id"] },
-    { fields: ["agent_id"] },
-    { fields: ["created_at"] }
-  ],
-  enable: {
-    trackHistory: false,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create", "update", "delete"],
-    trash: false,
-    mru: false
-  }
-});
-
-// src/objects/ai-message.object.ts
-var import_data2 = require("@objectstack/spec/data");
-var AiMessageObject = import_data2.ObjectSchema.create({
-  namespace: "ai",
-  name: "messages",
-  label: "AI Message",
-  pluralLabel: "AI Messages",
-  icon: "message-circle",
-  isSystem: true,
-  description: "Individual messages within AI conversations",
-  fields: {
-    id: import_data2.Field.text({
-      label: "Message ID",
-      required: true,
-      readonly: true
-    }),
-    conversation_id: import_data2.Field.text({
-      label: "Conversation ID",
-      required: true,
-      description: "Foreign key to ai_conversations"
-    }),
-    role: import_data2.Field.select({
-      label: "Role",
-      required: true,
-      options: [
-        { label: "System", value: "system" },
-        { label: "User", value: "user" },
-        { label: "Assistant", value: "assistant" },
-        { label: "Tool", value: "tool" }
-      ]
-    }),
-    content: import_data2.Field.textarea({
-      label: "Content",
-      required: true,
-      description: "Message content"
-    }),
-    tool_calls: import_data2.Field.textarea({
-      label: "Tool Calls",
-      required: false,
-      description: "JSON-serialized tool calls (when role=assistant)"
-    }),
-    tool_call_id: import_data2.Field.text({
-      label: "Tool Call ID",
-      required: false,
-      maxLength: 255,
-      description: "ID of the tool call this message responds to (when role=tool)"
-    }),
-    created_at: import_data2.Field.datetime({
-      label: "Created At",
-      required: true,
-      defaultValue: "NOW()",
-      readonly: true
-    })
-  },
-  indexes: [
-    { fields: ["conversation_id"] },
-    { fields: ["conversation_id", "created_at"] }
-  ],
-  enable: {
-    trackHistory: false,
-    searchable: false,
-    apiEnabled: true,
-    apiMethods: ["get", "list", "create"],
-    trash: false,
-    mru: false
-  }
-});
-
-// src/tools/data-tools.ts
-var MAX_QUERY_LIMIT = 200;
-var DEFAULT_QUERY_LIMIT = 20;
-var LIST_OBJECTS_TOOL = {
-  name: "list_objects",
-  description: "List all available data objects (tables) in the system. Returns object names and labels.",
-  parameters: {
-    type: "object",
-    properties: {},
-    additionalProperties: false
-  }
-};
-var DESCRIBE_OBJECT_TOOL = {
-  name: "describe_object",
-  description: "Get the schema (fields, types, labels) of a specific data object. Use this to understand the structure of a table before querying it.",
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "The snake_case name of the object to describe"
-      }
-    },
-    required: ["objectName"],
-    additionalProperties: false
-  }
-};
-var QUERY_RECORDS_TOOL = {
-  name: "query_records",
-  description: "Query records from a data object with optional filters, field selection, sorting, and pagination. Returns an array of matching records.",
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "The snake_case name of the object to query"
-      },
-      where: {
-        type: "object",
-        description: 'Filter conditions as key-value pairs (e.g. { "status": "active" }) or MongoDB-style operators (e.g. { "amount": { "$gt": 100 } })'
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: "List of field names to return (omit for all fields)"
-      },
-      orderBy: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            field: { type: "string" },
-            order: { type: "string", enum: ["asc", "desc"] }
+          return { status: 400, body: { error: "messages array is required" } };
+        }
+        for (const msg of messages) {
+          const err = validateMessage(msg);
+          if (err) return { status: 400, body: { error: err } };
+        }
+        try {
+          if (!aiService.streamChat) {
+            return { status: 501, body: { error: "Streaming is not supported by the configured AI service" } };
           }
-        },
-        description: 'Sort order (e.g. [{ "field": "created_at", "order": "desc" }])'
-      },
-      limit: {
-        type: "number",
-        description: `Maximum number of records to return (default ${DEFAULT_QUERY_LIMIT}, max ${MAX_QUERY_LIMIT})`
-      },
-      offset: {
-        type: "number",
-        description: "Number of records to skip for pagination"
+          const events = aiService.streamChat(messages.map((m) => normalizeMessage(m)), options);
+          return { status: 200, stream: true, events };
+        } catch (err) {
+          logger.error("[AI Route] /chat/stream error", err instanceof Error ? err : void 0);
+          return { status: 500, body: { error: "Internal AI service error" } };
+        }
       }
     },
-    required: ["objectName"],
-    additionalProperties: false
-  }
-};
-var GET_RECORD_TOOL = {
-  name: "get_record",
-  description: "Get a single record by its ID from a data object.",
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "The snake_case name of the object"
-      },
-      recordId: {
-        type: "string",
-        description: "The unique ID of the record"
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: "List of field names to return (omit for all fields)"
+    // ── Complete ────────────────────────────────────────────────
+    {
+      method: "POST",
+      path: "/api/v1/ai/complete",
+      description: "Text completion",
+      auth: true,
+      permissions: ["ai:complete"],
+      handler: async (req) => {
+        const { prompt, options } = req.body ?? {};
+        if (!prompt || typeof prompt !== "string") {
+          return { status: 400, body: { error: "prompt string is required" } };
+        }
+        try {
+          const result = await aiService.complete(prompt, options);
+          return { status: 200, body: result };
+        } catch (err) {
+          logger.error("[AI Route] /complete error", err instanceof Error ? err : void 0);
+          return { status: 500, body: { error: "Internal AI service error" } };
+        }
       }
     },
-    required: ["objectName", "recordId"],
-    additionalProperties: false
-  }
-};
-var AGGREGATE_DATA_TOOL = {
-  name: "aggregate_data",
-  description: "Perform aggregation/statistical operations on a data object. Supports count, sum, avg, min, max with optional groupBy and where filters.",
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "The snake_case name of the object to aggregate"
-      },
-      aggregations: {
-        type: "array",
-        items: {
-          type: "object",
-          properties: {
-            function: {
-              type: "string",
-              enum: ["count", "sum", "avg", "min", "max", "count_distinct"],
-              description: "Aggregation function"
-            },
-            field: {
-              type: "string",
-              description: "Field to aggregate (optional for count)"
-            },
-            alias: {
-              type: "string",
-              description: "Result column alias"
-            }
-          },
-          required: ["function", "alias"]
-        },
-        description: "Aggregation definitions"
-      },
-      groupBy: {
-        type: "array",
-        items: { type: "string" },
-        description: "Fields to group by"
-      },
-      where: {
-        type: "object",
-        description: "Filter conditions applied before aggregation"
+    // ── Models ──────────────────────────────────────────────────
+    {
+      method: "GET",
+      path: "/api/v1/ai/models",
+      description: "List available models",
+      auth: true,
+      permissions: ["ai:read"],
+      handler: async () => {
+        try {
+          const models = aiService.listModels ? await aiService.listModels() : [];
+          return { status: 200, body: { models } };
+        } catch (err) {
+          logger.error("[AI Route] /models error", err instanceof Error ? err : void 0);
+          return { status: 500, body: { error: "Internal AI service error" } };
+        }
       }
     },
-    required: ["objectName", "aggregations"],
-    additionalProperties: false
-  }
-};
-var DATA_TOOL_DEFINITIONS = [
-  LIST_OBJECTS_TOOL,
-  DESCRIBE_OBJECT_TOOL,
-  QUERY_RECORDS_TOOL,
-  GET_RECORD_TOOL,
-  AGGREGATE_DATA_TOOL
-];
-function createListObjectsHandler(ctx) {
-  return async () => {
-    const objects = await ctx.metadataService.listObjects();
-    const summary = objects.map((o) => ({
-      name: o.name,
-      label: o.label ?? o.name
-    }));
-    return JSON.stringify(summary);
-  };
-}
-function createDescribeObjectHandler(ctx) {
-  return async (args) => {
-    const { objectName } = args;
-    const objectDef = await ctx.metadataService.getObject(objectName);
-    if (!objectDef) {
-      return JSON.stringify({ error: `Object "${objectName}" not found` });
-    }
-    const def = objectDef;
-    const fields = def.fields ?? {};
-    const fieldSummary = {};
-    for (const [key, f] of Object.entries(fields)) {
-      fieldSummary[key] = {
-        type: f.type,
-        label: f.label ?? key,
-        required: f.required ?? false,
-        ...f.reference ? { reference: f.reference } : {},
-        ...f.options ? { options: f.options } : {}
-      };
-    }
-    return JSON.stringify({
-      name: def.name,
-      label: def.label ?? def.name,
-      fields: fieldSummary
-    });
-  };
-}
-function createQueryRecordsHandler(ctx) {
-  return async (args) => {
-    const {
-      objectName,
-      where,
-      fields,
-      orderBy,
-      limit,
-      offset
-    } = args;
-    const rawLimit = limit ?? DEFAULT_QUERY_LIMIT;
-    const safeLimit = Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(Math.floor(rawLimit), MAX_QUERY_LIMIT) : DEFAULT_QUERY_LIMIT;
-    const safeOffset = Number.isFinite(offset) && offset >= 0 ? Math.floor(offset) : void 0;
-    const records = await ctx.dataEngine.find(objectName, {
-      where,
-      fields,
-      orderBy,
-      limit: safeLimit,
-      offset: safeOffset
-    });
-    return JSON.stringify({ count: records.length, records });
-  };
-}
-function createGetRecordHandler(ctx) {
-  return async (args) => {
-    const { objectName, recordId, fields } = args;
-    const record = await ctx.dataEngine.findOne(objectName, {
-      where: { id: recordId },
-      fields
-    });
-    if (!record) {
-      return JSON.stringify({ error: `Record "${recordId}" not found in "${objectName}"` });
-    }
-    return JSON.stringify(record);
-  };
-}
-var VALID_AGG_FUNCTIONS = /* @__PURE__ */ new Set([
-  "count",
-  "sum",
-  "avg",
-  "min",
-  "max",
-  "count_distinct"
-]);
-function createAggregateDataHandler(ctx) {
-  return async (args) => {
-    const { objectName, aggregations, groupBy, where } = args;
-    for (const a of aggregations) {
-      if (!VALID_AGG_FUNCTIONS.has(a.function)) {
-        return JSON.stringify({
-          error: `Invalid aggregation function "${a.function}". Allowed: ${[...VALID_AGG_FUNCTIONS].join(", ")}`
-        });
-      }
-    }
-    const result = await ctx.dataEngine.aggregate(objectName, {
-      where,
-      groupBy,
-      aggregations: aggregations.map((a) => ({
-        function: a.function,
-        field: a.field,
-        alias: a.alias
-      }))
-    });
-    return JSON.stringify(result);
-  };
-}
-function registerDataTools(registry, context) {
-  registry.register(LIST_OBJECTS_TOOL, createListObjectsHandler(context));
-  registry.register(DESCRIBE_OBJECT_TOOL, createDescribeObjectHandler(context));
-  registry.register(QUERY_RECORDS_TOOL, createQueryRecordsHandler(context));
-  registry.register(GET_RECORD_TOOL, createGetRecordHandler(context));
-  registry.register(AGGREGATE_DATA_TOOL, createAggregateDataHandler(context));
-}
-
-// src/tools/create-object.tool.ts
-var import_ai = require("@objectstack/spec/ai");
-var createObjectTool = (0, import_ai.defineTool)({
-  name: "create_object",
-  label: "Create Object",
-  description: "Creates a new data object (table) with the specified name, label, and optional field definitions. Use this when the user wants to create a new entity, table, or data model.",
-  category: "data",
-  builtIn: true,
-  // NOTE: requiresConfirmation is intentionally false (default) because the
-  // server-side tool-call loop in AIService.chatWithTools/streamChatWithTools
-  // executes tool calls immediately without checking this flag.  The flag
-  // should only be set once server-side approval gating is implemented to
-  // avoid giving users a false sense of safety.
-  parameters: {
-    type: "object",
-    properties: {
-      name: {
-        type: "string",
-        description: "Machine name for the object (snake_case, e.g. project_task)"
-      },
-      label: {
-        type: "string",
-        description: "Human-readable display name (e.g. Project Task)"
-      },
-      fields: {
-        type: "array",
-        description: "Initial fields to create with the object",
-        items: {
-          type: "object",
-          properties: {
-            name: { type: "string", description: "Field machine name (snake_case)" },
-            label: { type: "string", description: "Field display name" },
-            type: {
-              type: "string",
-              description: "Field data type",
-              enum: ["text", "textarea", "number", "boolean", "date", "datetime", "select", "lookup", "formula", "autonumber"]
-            },
-            required: { type: "boolean", description: "Whether the field is required" }
-          },
-          required: ["name", "type"]
+    // ── Conversations ──────────────────────────────────────────
+    {
+      method: "POST",
+      path: "/api/v1/ai/conversations",
+      description: "Create a conversation",
+      auth: true,
+      permissions: ["ai:conversations"],
+      handler: async (req) => {
+        try {
+          if (req.body !== void 0 && req.body !== null && (typeof req.body !== "object" || Array.isArray(req.body))) {
+            return { status: 400, body: { error: "Invalid request payload" } };
+          }
+          const options = { ...req.body ?? {} };
+          if (req.user?.userId) {
+            options.userId = req.user.userId;
+          }
+          const conversation = await conversationService.create(options);
+          return { status: 201, body: conversation };
+        } catch (err) {
+          logger.error("[AI Route] POST /conversations error", err instanceof Error ? err : void 0);
+          return { status: 500, body: { error: "Internal AI service error" } };
         }
-      },
-      enableFeatures: {
-        type: "object",
-        description: "Object capability flags",
-        properties: {
-          trackHistory: { type: "boolean" },
-          apiEnabled: { type: "boolean" }
+      }
+    },
+    {
+      method: "GET",
+      path: "/api/v1/ai/conversations",
+      description: "List conversations",
+      auth: true,
+      permissions: ["ai:conversations"],
+      handler: async (req) => {
+        try {
+          const rawQuery = req.query ?? {};
+          const options = { ...rawQuery };
+          if (typeof rawQuery.limit === "string") {
+            const parsedLimit = Number(rawQuery.limit);
+            if (!Number.isFinite(parsedLimit) || parsedLimit <= 0 || !Number.isInteger(parsedLimit)) {
+              return { status: 400, body: { error: "Invalid limit parameter" } };
+            }
+            options.limit = parsedLimit;
+          }
+          if (req.user?.userId) {
+            options.userId = req.user.userId;
+          }
+          const conversations = await conversationService.list(options);
+          return { status: 200, body: { conversations } };
+        } catch (err) {
+          logger.error("[AI Route] GET /conversations error", err instanceof Error ? err : void 0);
+          return { status: 500, body: { error: "Internal AI service error" } };
         }
       }
     },
-    required: ["name", "label"],
-    additionalProperties: false
-  }
-});
-
-// src/tools/add-field.tool.ts
-var import_ai2 = require("@objectstack/spec/ai");
-var addFieldTool = (0, import_ai2.defineTool)({
-  name: "add_field",
-  label: "Add Field",
-  description: "Adds a new field (column) to an existing data object. Use this when the user wants to add a property, column, or attribute to a table.",
-  category: "data",
-  builtIn: true,
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "Target object machine name (snake_case)"
-      },
-      name: {
-        type: "string",
-        description: "Field machine name (snake_case, e.g. due_date)"
-      },
-      label: {
-        type: "string",
-        description: "Human-readable field label (e.g. Due Date)"
-      },
-      type: {
-        type: "string",
-        description: "Field data type",
-        enum: ["text", "textarea", "number", "boolean", "date", "datetime", "select", "lookup", "formula", "autonumber"]
-      },
-      required: {
-        type: "boolean",
-        description: "Whether the field is required"
-      },
-      defaultValue: {
-        description: "Default value for the field"
-      },
-      options: {
-        type: "array",
-        description: "Options for select/picklist fields",
-        items: {
-          type: "object",
-          properties: {
-            label: { type: "string" },
-            value: {
-              type: "string",
-              description: "Option machine identifier (lowercase snake_case, e.g. high_priority)",
-              pattern: "^[a-z_][a-z0-9_]*$"
+    {
+      method: "POST",
+      path: "/api/v1/ai/conversations/:id/messages",
+      description: "Add message to a conversation",
+      auth: true,
+      permissions: ["ai:conversations"],
+      handler: async (req) => {
+        const id = req.params?.id;
+        if (!id) {
+          return { status: 400, body: { error: "conversation id is required" } };
+        }
+        const message = req.body;
+        const validationError = validateMessage(message);
+        if (validationError) {
+          return { status: 400, body: { error: validationError } };
+        }
+        try {
+          if (req.user?.userId) {
+            const existing = await conversationService.get(id);
+            if (!existing) {
+              return { status: 404, body: { error: `Conversation "${id}" not found` } };
+            }
+            if (existing.userId && existing.userId !== req.user.userId) {
+              return { status: 403, body: { error: "You do not have access to this conversation" } };
             }
           }
+          const conversation = await conversationService.addMessage(id, message);
+          return { status: 200, body: conversation };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("not found")) {
+            return { status: 404, body: { error: msg } };
+          }
+          logger.error("[AI Route] POST /conversations/:id/messages error", err instanceof Error ? err : void 0);
+          return { status: 500, body: { error: "Internal AI service error" } };
         }
-      },
-      reference: {
-        type: "string",
-        description: "Referenced object name for lookup fields (snake_case, e.g. account)"
       }
     },
-    required: ["objectName", "name", "type"],
-    additionalProperties: false
-  }
-});
-
-// src/tools/modify-field.tool.ts
-var import_ai3 = require("@objectstack/spec/ai");
-var modifyFieldTool = (0, import_ai3.defineTool)({
-  name: "modify_field",
-  label: "Modify Field",
-  description: "Modifies an existing field definition (label, type, required, default value, etc.) on a data object. Use this when the user wants to change or reconfigure an existing column or attribute (not rename it).",
-  category: "data",
-  builtIn: true,
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "Target object machine name (snake_case)"
-      },
-      fieldName: {
-        type: "string",
-        description: "Existing field machine name to modify (snake_case)"
-      },
-      changes: {
-        type: "object",
-        description: "Field properties to update (partial patch)",
-        properties: {
-          label: { type: "string", description: "New display label" },
-          type: { type: "string", description: "New field type" },
-          required: { type: "boolean", description: "Update required constraint" },
-          defaultValue: { description: "New default value" }
+    {
+      method: "DELETE",
+      path: "/api/v1/ai/conversations/:id",
+      description: "Delete a conversation",
+      auth: true,
+      permissions: ["ai:conversations"],
+      handler: async (req) => {
+        const id = req.params?.id;
+        if (!id) {
+          return { status: 400, body: { error: "conversation id is required" } };
+        }
+        try {
+          if (req.user?.userId) {
+            const existing = await conversationService.get(id);
+            if (!existing) {
+              return { status: 404, body: { error: `Conversation "${id}" not found` } };
+            }
+            if (existing.userId && existing.userId !== req.user.userId) {
+              return { status: 403, body: { error: "You do not have access to this conversation" } };
+            }
+          }
+          await conversationService.delete(id);
+          return { status: 204 };
+        } catch (err) {
+          logger.error("[AI Route] DELETE /conversations/:id error", err instanceof Error ? err : void 0);
+          return { status: 500, body: { error: "Internal AI service error" } };
         }
       }
-    },
-    required: ["objectName", "fieldName", "changes"],
-    additionalProperties: false
-  }
-});
+    }
+  ];
+}
 
-// src/tools/delete-field.tool.ts
-var import_ai4 = require("@objectstack/spec/ai");
-var deleteFieldTool = (0, import_ai4.defineTool)({
-  name: "delete_field",
-  label: "Delete Field",
-  description: "Removes a field (column) from an existing data object. This is a destructive operation. Use this when the user explicitly wants to remove an attribute or column from a table.",
-  category: "data",
-  builtIn: true,
-  // NOTE: requiresConfirmation is intentionally false (default) because the
-  // server-side tool-call loop in AIService.chatWithTools/streamChatWithTools
-  // executes tool calls immediately without checking this flag.  The flag
-  // should only be set once server-side approval gating is implemented.
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "Target object machine name (snake_case)"
-      },
-      fieldName: {
-        type: "string",
-        description: "Field machine name to delete (snake_case)"
-      }
-    },
-    required: ["objectName", "fieldName"],
-    additionalProperties: false
+// src/routes/agent-routes.ts
+var ALLOWED_AGENT_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
+function validateAgentMessage(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    return "each message must be an object";
   }
-});
-
-// src/tools/list-metadata-objects.tool.ts
-var import_ai5 = require("@objectstack/spec/ai");
-var listMetadataObjectsTool = (0, import_ai5.defineTool)({
-  name: "list_metadata_objects",
-  label: "List Metadata Objects",
-  description: "Lists all registered metadata objects (tables) in the current environment. Use this when the user wants to see what tables, entities, or data models are defined in metadata.",
-  category: "data",
-  builtIn: true,
-  parameters: {
-    type: "object",
-    properties: {
-      filter: {
-        type: "string",
-        description: "Optional name or label substring to filter objects"
-      },
-      includeFields: {
-        type: "boolean",
-        description: "Whether to include field summaries for each object (default: false)"
-      }
-    },
-    additionalProperties: false
+  const msg = raw;
+  if (typeof msg.role !== "string" || !ALLOWED_AGENT_ROLES.has(msg.role)) {
+    return `message.role must be one of ${[...ALLOWED_AGENT_ROLES].map((r) => `"${r}"`).join(", ")} for agent chat`;
   }
-});
-
-// src/tools/describe-metadata-object.tool.ts
-var import_ai6 = require("@objectstack/spec/ai");
-var describeMetadataObjectTool = (0, import_ai6.defineTool)({
-  name: "describe_metadata_object",
-  label: "Describe Metadata Object",
-  description: "Returns the full metadata schema details of a data object, including all fields, types, relationships, and configuration. Use this when the user wants to inspect or understand the metadata structure of a specific table or entity.",
-  category: "data",
-  builtIn: true,
-  parameters: {
-    type: "object",
-    properties: {
-      objectName: {
-        type: "string",
-        description: "Object machine name to describe (snake_case)"
+  const allowEmpty = msg.role === "assistant";
+  return validateMessageContent(msg, { allowEmptyContent: allowEmpty });
+}
+function buildAgentRoutes(aiService, agentRuntime, logger) {
+  return [
+    // ── List active agents ──────────────────────────────────────
+    {
+      method: "GET",
+      path: "/api/v1/ai/agents",
+      description: "List all active AI agents",
+      auth: true,
+      permissions: ["ai:chat"],
+      handler: async () => {
+        try {
+          const agents = await agentRuntime.listAgents();
+          return { status: 200, body: { agents } };
+        } catch (err) {
+          logger.error(
+            "[AI Route] /agents list error",
+            err instanceof Error ? err : void 0
+          );
+          return { status: 500, body: { error: "Internal AI service error" } };
+        }
       }
     },
-    required: ["objectName"],
-    additionalProperties: false
-  }
-});
-
-// src/tools/metadata-tools.ts
-var METADATA_TOOL_DEFINITIONS = [
-  createObjectTool,
-  addFieldTool,
-  modifyFieldTool,
-  deleteFieldTool,
-  listMetadataObjectsTool,
-  describeMetadataObjectTool
-];
-var SNAKE_CASE_RE = /^[a-z_][a-z0-9_]*$/;
-function isSnakeCase(value) {
-  return SNAKE_CASE_RE.test(value);
-}
-function createCreateObjectHandler(ctx) {
-  return async (args) => {
-    const { name, label, fields, enableFeatures } = args;
-    if (!name || !label) {
-      return JSON.stringify({ error: 'Both "name" and "label" are required' });
-    }
-    if (!isSnakeCase(name)) {
-      return JSON.stringify({ error: `Invalid object name "${name}". Must be snake_case.` });
-    }
-    const existing = await ctx.metadataService.getObject(name);
-    if (existing) {
-      return JSON.stringify({ error: `Object "${name}" already exists` });
-    }
-    const fieldMap = {};
-    if (fields && Array.isArray(fields)) {
-      const seenNames = /* @__PURE__ */ new Set();
-      for (const f of fields) {
-        if (!f.name) {
-          return JSON.stringify({ error: 'Each field must have a "name" property' });
+    // ── Chat with a specific agent ──────────────────────────────
+    //
+    // Dual-mode endpoint matching the general chat route behaviour:
+    //   • `stream !== false` → Vercel Data Stream Protocol (SSE)
+    //   • `stream === false`  → JSON response (legacy)
+    //
+    {
+      method: "POST",
+      path: "/api/v1/ai/agents/:agentName/chat",
+      description: "Chat with a specific AI agent (supports Vercel AI Data Stream Protocol)",
+      auth: true,
+      permissions: ["ai:chat", "ai:agents"],
+      handler: async (req) => {
+        const agentName = req.params?.agentName;
+        if (!agentName) {
+          return { status: 400, body: { error: "agentName parameter is required" } };
         }
-        if (!isSnakeCase(f.name)) {
-          return JSON.stringify({ error: `Invalid field name "${f.name}". Must be snake_case.` });
+        const body = req.body ?? {};
+        const {
+          messages: rawMessages,
+          context: chatContext,
+          options: extraOptions
+        } = body;
+        if (!Array.isArray(rawMessages) || rawMessages.length === 0) {
+          return { status: 400, body: { error: "messages array is required" } };
         }
-        if (seenNames.has(f.name)) {
-          return JSON.stringify({ error: `Duplicate field name "${f.name}" in initial fields` });
+        for (const msg of rawMessages) {
+          const err = validateAgentMessage(msg);
+          if (err) return { status: 400, body: { error: err } };
+        }
+        const agent = await agentRuntime.loadAgent(agentName);
+        if (!agent) {
+          return { status: 404, body: { error: `Agent "${agentName}" not found` } };
+        }
+        if (!agent.active) {
+          return { status: 403, body: { error: `Agent "${agentName}" is not active` } };
+        }
+        try {
+          const systemMessages = agentRuntime.buildSystemMessages(agent, chatContext);
+          const agentOptions = agentRuntime.buildRequestOptions(
+            agent,
+            aiService.toolRegistry.getAll()
+          );
+          const safeOverrides = {};
+          if (extraOptions) {
+            const ALLOWED_KEYS = /* @__PURE__ */ new Set(["temperature", "maxTokens", "stop"]);
+            for (const key of Object.keys(extraOptions)) {
+              if (ALLOWED_KEYS.has(key)) {
+                safeOverrides[key] = extraOptions[key];
+              }
+            }
+          }
+          const mergedOptions = { ...agentOptions, ...safeOverrides };
+          const fullMessages = [
+            ...systemMessages,
+            ...rawMessages.map((m) => normalizeMessage(m))
+          ];
+          const chatWithToolsOptions = {
+            ...mergedOptions,
+            maxIterations: agent.planning?.maxIterations
+          };
+          const wantStream = body.stream !== false;
+          if (wantStream) {
+            if (!aiService.streamChatWithTools) {
+              return { status: 501, body: { error: "Streaming is not supported by the configured AI service" } };
+            }
+            const events = aiService.streamChatWithTools(fullMessages, chatWithToolsOptions);
+            return {
+              status: 200,
+              stream: true,
+              vercelDataStream: true,
+              contentType: "text/event-stream",
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "x-vercel-ai-ui-message-stream": "v1"
+              },
+              events: encodeVercelDataStream(events)
+            };
+          }
+          const result = await aiService.chatWithTools(fullMessages, chatWithToolsOptions);
+          return { status: 200, body: result };
+        } catch (err) {
+          logger.error(
+            "[AI Route] /agents/:agentName/chat error",
+            err instanceof Error ? err : void 0
+          );
+          return { status: 500, body: { error: "Internal AI service error" } };
         }
-        seenNames.add(f.name);
-        fieldMap[f.name] = {
-          type: f.type,
-          ...f.label ? { label: f.label } : {},
-          ...f.required !== void 0 ? { required: f.required } : {}
-        };
       }
     }
-    const objectDef = {
-      name,
-      label,
-      ...Object.keys(fieldMap).length > 0 ? { fields: fieldMap } : {},
-      ...enableFeatures ? { enable: enableFeatures } : {}
-    };
-    await ctx.metadataService.register("object", name, objectDef);
-    return JSON.stringify({
-      name,
-      label,
-      fieldCount: Object.keys(fieldMap).length
-    });
-  };
+  ];
 }
-function createAddFieldHandler(ctx) {
-  return async (args) => {
-    const { objectName, name, label, type, required, defaultValue, options, reference } = args;
-    if (!objectName || !name || !type) {
-      return JSON.stringify({ error: '"objectName", "name", and "type" are required' });
-    }
-    if (!isSnakeCase(objectName)) {
-      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
-    }
-    if (!isSnakeCase(name)) {
-      return JSON.stringify({ error: `Invalid field name "${name}". Must be snake_case.` });
-    }
-    if (reference && !isSnakeCase(reference)) {
-      return JSON.stringify({ error: `Invalid reference "${reference}". Must be a snake_case object name.` });
-    }
-    if (options && Array.isArray(options)) {
-      for (const opt of options) {
-        if (opt.value && !isSnakeCase(opt.value)) {
-          return JSON.stringify({ error: `Invalid option value "${opt.value}". Must be lowercase snake_case.` });
+
+// src/routes/tool-routes.ts
+function extractOutputValue(output) {
+  if (!output) return "";
+  if (typeof output === "string") return output;
+  if (typeof output === "object" && "value" in output) {
+    return String(output.value ?? "");
+  }
+  return JSON.stringify(output);
+}
+function buildToolRoutes(aiService, logger) {
+  return [
+    // ── List registered tools ──────────────────────────────────────
+    {
+      method: "GET",
+      path: "/api/v1/ai/tools",
+      description: "List all registered AI tools",
+      auth: true,
+      permissions: ["ai:tools"],
+      handler: async () => {
+        try {
+          const tools = aiService.toolRegistry.getAll();
+          return {
+            status: 200,
+            body: {
+              tools: tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                category: t.category
+              }))
+            }
+          };
+        } catch (err) {
+          logger.error(
+            "[AI Route] /tools list error",
+            err instanceof Error ? err : void 0
+          );
+          return { status: 500, body: { error: "Internal AI service error" } };
+        }
+      }
+    },
+    // ── Execute a tool ──────────────────────────────────────────────
+    //
+    // Executes a tool with the provided parameters.
+    // This is intended for testing/playground use.
+    //
+    {
+      method: "POST",
+      path: "/api/v1/ai/tools/:toolName/execute",
+      description: "Execute a tool with parameters (playground/testing)",
+      auth: true,
+      permissions: ["ai:tools", "ai:execute"],
+      handler: async (req) => {
+        const toolName = req.params?.toolName;
+        if (!toolName) {
+          return { status: 400, body: { error: "toolName parameter is required" } };
+        }
+        const body = req.body ?? {};
+        const { parameters } = body;
+        if (!parameters || typeof parameters !== "object") {
+          return { status: 400, body: { error: "parameters object is required" } };
+        }
+        try {
+          if (!aiService.toolRegistry.has(toolName)) {
+            return { status: 404, body: { error: `Tool "${toolName}" not found` } };
+          }
+          const startTime = Date.now();
+          const toolCallPart = {
+            type: "tool-call",
+            toolCallId: `playground-${Date.now()}`,
+            toolName,
+            input: parameters
+          };
+          const result = await aiService.toolRegistry.execute(toolCallPart);
+          const duration = Date.now() - startTime;
+          if (result.isError) {
+            const errorMsg = extractOutputValue(result.output);
+            logger.error(
+              `[AI Route] Tool execution error: ${toolName}`,
+              new Error(errorMsg)
+            );
+            return {
+              status: 500,
+              body: {
+                error: errorMsg,
+                duration
+              }
+            };
+          }
+          return {
+            status: 200,
+            body: {
+              result: extractOutputValue(result.output),
+              duration,
+              toolName
+            }
+          };
+        } catch (err) {
+          logger.error(
+            "[AI Route] /tools/:toolName/execute error",
+            err instanceof Error ? err : void 0
+          );
+          return { status: 500, body: { error: "Internal AI service error" } };
         }
       }
     }
-    const objectDef = await ctx.metadataService.getObject(objectName);
-    if (!objectDef) {
-      return JSON.stringify({ error: `Object "${objectName}" not found` });
-    }
-    const def = objectDef;
-    if (def.fields && def.fields[name]) {
-      return JSON.stringify({ error: `Field "${name}" already exists on object "${objectName}"` });
-    }
-    const fieldDef = {
-      type,
-      ...label ? { label } : {},
-      ...required !== void 0 ? { required } : {},
-      ...defaultValue !== void 0 ? { defaultValue } : {},
-      ...options ? { options } : {},
-      ...reference ? { reference } : {}
+  ];
+}
+
+// src/conversation/objectql-conversation-service.ts
+var import_node_crypto = require("crypto");
+var CONVERSATIONS_OBJECT = "ai_conversations";
+var MESSAGES_OBJECT = "ai_messages";
+var CONVERSATION_ORDER = [
+  { field: "created_at", order: "asc" },
+  { field: "id", order: "asc" }
+];
+var MESSAGE_ORDER = [
+  { field: "created_at", order: "asc" },
+  { field: "id", order: "asc" }
+];
+var ObjectQLConversationService = class {
+  constructor(engine) {
+    this.engine = engine;
+  }
+  async create(options = {}) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const id = `conv_${(0, import_node_crypto.randomUUID)()}`;
+    const record = {
+      id,
+      title: options.title ?? null,
+      agent_id: options.agentId ?? null,
+      user_id: options.userId ?? null,
+      metadata: options.metadata ? JSON.stringify(options.metadata) : null,
+      created_at: now,
+      updated_at: now
     };
-    const updatedFields = { ...def.fields ?? {}, [name]: fieldDef };
-    await ctx.metadataService.register("object", objectName, {
-      ...def,
-      fields: updatedFields
+    await this.engine.insert(CONVERSATIONS_OBJECT, record);
+    return {
+      id,
+      title: options.title,
+      agentId: options.agentId,
+      userId: options.userId,
+      messages: [],
+      createdAt: now,
+      updatedAt: now,
+      metadata: options.metadata
+    };
+  }
+  async get(conversationId) {
+    const row = await this.engine.findOne(CONVERSATIONS_OBJECT, {
+      where: { id: conversationId }
     });
-    return JSON.stringify({
-      objectName,
-      fieldName: name,
-      fieldType: type
+    if (!row) return null;
+    const messages = await this.engine.find(MESSAGES_OBJECT, {
+      where: { conversation_id: conversationId },
+      orderBy: MESSAGE_ORDER
     });
-  };
-}
-function createModifyFieldHandler(ctx) {
-  return async (args) => {
-    const { objectName, fieldName, changes } = args;
-    if (!objectName || !fieldName || !changes) {
-      return JSON.stringify({ error: '"objectName", "fieldName", and "changes" are required' });
-    }
-    if (!isSnakeCase(objectName)) {
-      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
-    }
-    if (!isSnakeCase(fieldName)) {
-      return JSON.stringify({ error: `Invalid field name "${fieldName}". Must be snake_case.` });
-    }
-    const objectDef = await ctx.metadataService.getObject(objectName);
-    if (!objectDef) {
-      return JSON.stringify({ error: `Object "${objectName}" not found` });
-    }
-    const def = objectDef;
-    if (!def.fields || !def.fields[fieldName]) {
-      return JSON.stringify({ error: `Field "${fieldName}" not found on object "${objectName}"` });
+    return this.toConversation(row, messages);
+  }
+  async list(options = {}) {
+    const where = {};
+    if (options.userId) where.user_id = options.userId;
+    if (options.agentId) where.agent_id = options.agentId;
+    if (options.cursor) {
+      const cursorRow = await this.engine.findOne(CONVERSATIONS_OBJECT, {
+        where: { id: options.cursor },
+        fields: ["created_at", "id"]
+      });
+      if (cursorRow) {
+        where.$or = [
+          { created_at: { $gt: cursorRow.created_at } },
+          { created_at: cursorRow.created_at, id: { $gt: cursorRow.id } }
+        ];
+      }
     }
-    const existingField = def.fields[fieldName];
-    const updatedField = { ...existingField, ...changes };
-    const updatedFields = { ...def.fields, [fieldName]: updatedField };
-    await ctx.metadataService.register("object", objectName, {
-      ...def,
-      fields: updatedFields
+    const rows = await this.engine.find(CONVERSATIONS_OBJECT, {
+      where: Object.keys(where).length > 0 ? where : void 0,
+      orderBy: CONVERSATION_ORDER,
+      limit: options.limit && options.limit > 0 ? options.limit : void 0
     });
-    return JSON.stringify({
-      objectName,
-      fieldName,
-      updatedProperties: Object.keys(changes)
+    const conversations = await Promise.all(
+      rows.map(async (row) => {
+        const messages = await this.engine.find(MESSAGES_OBJECT, {
+          where: { conversation_id: row.id },
+          orderBy: MESSAGE_ORDER
+        });
+        return this.toConversation(row, messages);
+      })
+    );
+    return conversations;
+  }
+  async addMessage(conversationId, message) {
+    const row = await this.engine.findOne(CONVERSATIONS_OBJECT, {
+      where: { id: conversationId }
     });
-  };
-}
-function createDeleteFieldHandler(ctx) {
-  return async (args) => {
-    const { objectName, fieldName } = args;
-    if (!objectName || !fieldName) {
-      return JSON.stringify({ error: '"objectName" and "fieldName" are required' });
-    }
-    if (!isSnakeCase(objectName)) {
-      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
-    }
-    if (!isSnakeCase(fieldName)) {
-      return JSON.stringify({ error: `Invalid field name "${fieldName}". Must be snake_case.` });
-    }
-    const objectDef = await ctx.metadataService.getObject(objectName);
-    if (!objectDef) {
-      return JSON.stringify({ error: `Object "${objectName}" not found` });
-    }
-    const def = objectDef;
-    if (!def.fields || !def.fields[fieldName]) {
-      return JSON.stringify({ error: `Field "${fieldName}" not found on object "${objectName}"` });
+    if (!row) {
+      throw new Error(`Conversation "${conversationId}" not found`);
     }
-    const { [fieldName]: _removed, ...remainingFields } = def.fields;
-    await ctx.metadataService.register("object", objectName, {
-      ...def,
-      fields: remainingFields
-    });
-    return JSON.stringify({
-      objectName,
-      fieldName,
-      success: true
-    });
-  };
-}
-function createListObjectsHandler2(ctx) {
-  return async (args) => {
-    const { filter, includeFields } = args ?? {};
-    const objects = await ctx.metadataService.listObjects();
-    let result = objects.map((o) => {
-      const base = {
-        name: o.name,
-        label: o.label ?? o.name,
-        fieldCount: o.fields ? Object.keys(o.fields).length : 0
-      };
-      if (includeFields && o.fields) {
-        base.fields = Object.entries(o.fields).map(([key, f]) => ({
-          name: key,
-          type: f.type,
-          label: f.label ?? key
-        }));
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const msgId = `msg_${(0, import_node_crypto.randomUUID)()}`;
+    let contentStr;
+    let toolCallsJson = null;
+    let toolCallId = null;
+    if (message.role === "system" || message.role === "user") {
+      contentStr = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+    } else if (message.role === "assistant") {
+      if (typeof message.content === "string") {
+        contentStr = message.content;
+      } else {
+        const parts = message.content;
+        const textParts = parts.filter((p) => p.type === "text").map((p) => p.text);
+        const toolCalls = parts.filter((p) => p.type === "tool-call");
+        contentStr = textParts.join("");
+        if (toolCalls.length > 0) toolCallsJson = JSON.stringify(toolCalls);
       }
-      return base;
-    });
-    if (filter) {
-      const lower = filter.toLowerCase();
-      result = result.filter(
-        (o) => o.name.toLowerCase().includes(lower) || o.label.toLowerCase().includes(lower)
-      );
+    } else if (message.role === "tool") {
+      contentStr = JSON.stringify(message.content);
+      const firstResult = Array.isArray(message.content) ? message.content[0] : void 0;
+      if (firstResult && "toolCallId" in firstResult) toolCallId = firstResult.toolCallId;
+    } else {
+      contentStr = "";
     }
-    return JSON.stringify({
-      objects: result,
-      totalCount: result.length
+    await this.engine.insert(MESSAGES_OBJECT, {
+      id: msgId,
+      conversation_id: conversationId,
+      role: message.role,
+      content: contentStr,
+      tool_calls: toolCallsJson,
+      tool_call_id: toolCallId,
+      created_at: now
     });
-  };
-}
-function createDescribeObjectHandler2(ctx) {
-  return async (args) => {
-    const { objectName } = args;
-    if (!objectName) {
-      return JSON.stringify({ error: '"objectName" is required' });
-    }
-    if (!isSnakeCase(objectName)) {
-      return JSON.stringify({ error: `Invalid object name "${objectName}". Must be snake_case.` });
+    await this.engine.update(CONVERSATIONS_OBJECT, { id: conversationId, updated_at: now }, {
+      where: { id: conversationId }
+    });
+    return await this.get(conversationId);
+  }
+  async delete(conversationId) {
+    await this.engine.delete(MESSAGES_OBJECT, {
+      where: { conversation_id: conversationId },
+      multi: true
+    });
+    await this.engine.delete(CONVERSATIONS_OBJECT, {
+      where: { id: conversationId }
+    });
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  /**
+   * Safely parse a JSON string, returning `undefined` on failure.
+   */
+  safeParse(value, fallback) {
+    if (!value) return void 0;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return fallback;
     }
-    const objectDef = await ctx.metadataService.getObject(objectName);
-    if (!objectDef) {
-      return JSON.stringify({ error: `Object "${objectName}" not found` });
+  }
+  /**
+   * Map a database row + message rows to an AIConversation.
+   */
+  toConversation(row, messageRows) {
+    return {
+      id: row.id,
+      title: row.title ?? void 0,
+      agentId: row.agent_id ?? void 0,
+      userId: row.user_id ?? void 0,
+      messages: messageRows.map((m) => this.toMessage(m)),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      metadata: this.safeParse(row.metadata)
+    };
+  }
+  /**
+   * Map a database row to a ModelMessage.
+   */
+  toMessage(row) {
+    switch (row.role) {
+      case "system":
+        return { role: "system", content: row.content };
+      case "user":
+        return { role: "user", content: row.content };
+      case "assistant": {
+        const toolCalls = this.safeParse(row.tool_calls);
+        if (toolCalls && toolCalls.length > 0) {
+          const content = [];
+          if (row.content) content.push({ type: "text", text: row.content });
+          content.push(...toolCalls);
+          return { role: "assistant", content };
+        }
+        return { role: "assistant", content: row.content };
+      }
+      case "tool": {
+        const toolResults = this.safeParse(row.content);
+        if (toolResults && toolResults.length > 0 && toolResults[0]?.type === "tool-result") {
+          return { role: "tool", content: toolResults };
+        }
+        return {
+          role: "tool",
+          content: [{
+            type: "tool-result",
+            toolCallId: row.tool_call_id ?? "",
+            toolName: "unknown",
+            output: { type: "text", value: row.content }
+          }]
+        };
+      }
+      default:
+        return { role: "user", content: row.content };
     }
-    const def = objectDef;
-    const fields = def.fields ?? {};
-    const fieldSummary = Object.entries(fields).map(([key, f]) => ({
-      name: key,
-      type: f.type,
-      label: f.label ?? key,
-      required: f.required ?? false,
-      ...f.reference ? { reference: f.reference } : {},
-      ...f.options ? { options: f.options } : {}
-    }));
-    return JSON.stringify({
-      name: def.name,
-      label: def.label ?? def.name,
-      fields: fieldSummary,
-      enableFeatures: def.enable ?? {}
-    });
-  };
-}
-function registerMetadataTools(registry, context) {
-  registry.register(createObjectTool, createCreateObjectHandler(context));
-  registry.register(addFieldTool, createAddFieldHandler(context));
-  registry.register(modifyFieldTool, createModifyFieldHandler(context));
-  registry.register(deleteFieldTool, createDeleteFieldHandler(context));
-  registry.register(listMetadataObjectsTool, createListObjectsHandler2(context));
-  registry.register(describeMetadataObjectTool, createDescribeObjectHandler2(context));
-}
+  }
+};
+
+// src/objects/ai-conversation.object.ts
+var import_data = require("@objectstack/spec/data");
+var AiConversationObject = import_data.ObjectSchema.create({
+  namespace: "ai",
+  name: "conversations",
+  label: "AI Conversation",
+  pluralLabel: "AI Conversations",
+  icon: "message-square",
+  isSystem: true,
+  description: "Persistent AI conversation metadata",
+  fields: {
+    id: import_data.Field.text({
+      label: "Conversation ID",
+      required: true,
+      readonly: true
+    }),
+    title: import_data.Field.text({
+      label: "Title",
+      required: false,
+      maxLength: 500,
+      description: "Conversation title or summary"
+    }),
+    agent_id: import_data.Field.text({
+      label: "Agent ID",
+      required: false,
+      maxLength: 255,
+      description: "Associated AI agent identifier"
+    }),
+    user_id: import_data.Field.text({
+      label: "User ID",
+      required: false,
+      maxLength: 255,
+      description: "User who owns the conversation"
+    }),
+    metadata: import_data.Field.textarea({
+      label: "Metadata",
+      required: false,
+      description: "JSON-serialized conversation metadata"
+    }),
+    created_at: import_data.Field.datetime({
+      label: "Created At",
+      required: true,
+      defaultValue: "NOW()",
+      readonly: true
+    }),
+    updated_at: import_data.Field.datetime({
+      label: "Updated At",
+      required: true,
+      defaultValue: "NOW()",
+      readonly: true
+    })
+  },
+  indexes: [
+    { fields: ["user_id"] },
+    { fields: ["agent_id"] },
+    { fields: ["created_at"] }
+  ],
+  enable: {
+    trackHistory: false,
+    searchable: false,
+    apiEnabled: true,
+    apiMethods: ["get", "list", "create", "update", "delete"],
+    trash: false,
+    mru: false
+  }
+});
+
+// src/objects/ai-message.object.ts
+var import_data2 = require("@objectstack/spec/data");
+var AiMessageObject = import_data2.ObjectSchema.create({
+  namespace: "ai",
+  name: "messages",
+  label: "AI Message",
+  pluralLabel: "AI Messages",
+  icon: "message-circle",
+  isSystem: true,
+  description: "Individual messages within AI conversations",
+  fields: {
+    id: import_data2.Field.text({
+      label: "Message ID",
+      required: true,
+      readonly: true
+    }),
+    conversation_id: import_data2.Field.text({
+      label: "Conversation ID",
+      required: true,
+      description: "Foreign key to ai_conversations"
+    }),
+    role: import_data2.Field.select({
+      label: "Role",
+      required: true,
+      options: [
+        { label: "System", value: "system" },
+        { label: "User", value: "user" },
+        { label: "Assistant", value: "assistant" },
+        { label: "Tool", value: "tool" }
+      ]
+    }),
+    content: import_data2.Field.textarea({
+      label: "Content",
+      required: true,
+      description: "Message content"
+    }),
+    tool_calls: import_data2.Field.textarea({
+      label: "Tool Calls",
+      required: false,
+      description: "JSON-serialized tool calls (when role=assistant)"
+    }),
+    tool_call_id: import_data2.Field.text({
+      label: "Tool Call ID",
+      required: false,
+      maxLength: 255,
+      description: "ID of the tool call this message responds to (when role=tool)"
+    }),
+    created_at: import_data2.Field.datetime({
+      label: "Created At",
+      required: true,
+      defaultValue: "NOW()",
+      readonly: true
+    })
+  },
+  indexes: [
+    { fields: ["conversation_id"] },
+    { fields: ["conversation_id", "created_at"] }
+  ],
+  enable: {
+    trackHistory: false,
+    searchable: false,
+    apiEnabled: true,
+    apiMethods: ["get", "list", "create"],
+    trash: false,
+    mru: false
+  }
+});
+
+// src/plugin.ts
+init_data_tools();
+init_metadata_tools();
 
 // src/agent-runtime.ts
 var import_ai7 = require("@objectstack/spec/ai");
@@ -2230,8 +2412,8 @@ Capabilities:
 - Describe the full schema of a specific object
 
 Guidelines:
-1. Before creating a new object, use list_metadata_objects to check if a similar one already exists.
-2. Before modifying or deleting fields, use describe_metadata_object to understand the current schema.
+1. Before creating a new object, use list_objects to check if a similar one already exists.
+2. Before modifying or deleting fields, use describe_object to understand the current schema.
 3. Always use snake_case for object names and field names (e.g. project_task, due_date).
 4. Suggest meaningful field types based on the user's description (e.g. "deadline" \u2192 date, "active" \u2192 boolean).
 5. When creating objects, propose a reasonable set of initial fields based on the entity type.
@@ -2251,8 +2433,8 @@ Guidelines:
     { type: "action", name: "add_field", description: "Add a field to an existing object" },
     { type: "action", name: "modify_field", description: "Modify an existing field definition" },
     { type: "action", name: "delete_field", description: "Delete a field from an object" },
-    { type: "query", name: "list_metadata_objects", description: "List all metadata objects" },
-    { type: "query", name: "describe_metadata_object", description: "Describe an object schema" }
+    { type: "query", name: "list_objects", description: "List all data objects" },
+    { type: "query", name: "describe_object", description: "Describe an object schema" }
   ],
   active: true,
   visibility: "global",
@@ -2503,8 +2685,8 @@ var AIServicePlugin = class {
         setupNav.contribute({
           areaId: "area_ai",
           items: [
-            { id: "nav_ai_conversations", type: "object", label: { key: "setup.nav.ai_conversations", defaultValue: "Conversations" }, objectName: "conversations", icon: "message-square", order: 10 },
-            { id: "nav_ai_messages", type: "object", label: { key: "setup.nav.ai_messages", defaultValue: "Messages" }, objectName: "messages", icon: "messages-square", order: 20 }
+            { id: "nav_ai_conversations", type: "object", label: "Conversations", objectName: "conversations", icon: "message-square", order: 10 },
+            { id: "nav_ai_messages", type: "object", label: "Messages", objectName: "messages", icon: "messages-square", order: 20 }
           ]
         });
         ctx.logger.info("[AI] Navigation items contributed to Setup App");
@@ -2518,20 +2700,40 @@ var AIServicePlugin = class {
     let metadataService;
     try {
       metadataService = ctx.getService("metadata");
-    } catch {
+      console.log("[AI Plugin] Retrieved metadata service:", !!metadataService, "has getRegisteredTypes:", typeof metadataService?.getRegisteredTypes);
+    } catch (e) {
+      console.log("[AI] Metadata service not available:", e.message);
       ctx.logger.debug("[AI] Metadata service not available");
     }
     try {
       const dataEngine = ctx.getService("data");
-      if (dataEngine && metadataService) {
-        registerDataTools(this.service.toolRegistry, { dataEngine, metadataService });
+      if (dataEngine) {
+        registerDataTools(this.service.toolRegistry, { dataEngine });
         ctx.logger.info("[AI] Built-in data tools registered");
-        const agentExists = typeof metadataService.exists === "function" ? await metadataService.exists("agent", DATA_CHAT_AGENT.name) : false;
-        if (!agentExists) {
-          await metadataService.register("agent", DATA_CHAT_AGENT.name, DATA_CHAT_AGENT);
-          ctx.logger.info("[AI] data_chat agent registered");
-        } else {
-          ctx.logger.debug("[AI] data_chat agent already exists, skipping auto-registration");
+        if (metadataService) {
+          const { DATA_TOOL_DEFINITIONS: DATA_TOOL_DEFINITIONS2 } = await Promise.resolve().then(() => (init_data_tools(), data_tools_exports));
+          for (const toolDef of DATA_TOOL_DEFINITIONS2) {
+            const toolExists = typeof metadataService.exists === "function" ? await metadataService.exists("tool", toolDef.name) : false;
+            if (!toolExists) {
+              await metadataService.register("tool", toolDef.name, toolDef);
+            }
+          }
+          ctx.logger.info(`[AI] ${DATA_TOOL_DEFINITIONS2.length} data tools registered as metadata`);
+        }
+        if (metadataService) {
+          try {
+            const agentExists = typeof metadataService.exists === "function" ? await metadataService.exists("agent", DATA_CHAT_AGENT.name) : false;
+            if (!agentExists) {
+              await metadataService.register("agent", DATA_CHAT_AGENT.name, DATA_CHAT_AGENT);
+              console.log("[AI] Registered data_chat agent to metadataService");
+              ctx.logger.info("[AI] data_chat agent registered");
+            } else {
+              console.log("[AI] data_chat agent already exists, skipping");
+              ctx.logger.debug("[AI] data_chat agent already exists, skipping auto-registration");
+            }
+          } catch (err) {
+            ctx.logger.warn("[AI] Failed to register data_chat agent", err instanceof Error ? { error: err.message, stack: err.stack } : { error: String(err) });
+          }
         }
       }
     } catch {
@@ -2541,12 +2743,26 @@ var AIServicePlugin = class {
       try {
         registerMetadataTools(this.service.toolRegistry, { metadataService });
         ctx.logger.info("[AI] Built-in metadata tools registered");
-        const agentExists = typeof metadataService.exists === "function" ? await metadataService.exists("agent", METADATA_ASSISTANT_AGENT.name) : false;
-        if (!agentExists) {
-          await metadataService.register("agent", METADATA_ASSISTANT_AGENT.name, METADATA_ASSISTANT_AGENT);
-          ctx.logger.info("[AI] metadata_assistant agent registered");
-        } else {
-          ctx.logger.debug("[AI] metadata_assistant agent already exists, skipping auto-registration");
+        const { METADATA_TOOL_DEFINITIONS: METADATA_TOOL_DEFINITIONS2 } = await Promise.resolve().then(() => (init_metadata_tools(), metadata_tools_exports));
+        for (const toolDef of METADATA_TOOL_DEFINITIONS2) {
+          const toolExists = typeof metadataService.exists === "function" ? await metadataService.exists("tool", toolDef.name) : false;
+          if (!toolExists) {
+            await metadataService.register("tool", toolDef.name, toolDef);
+          }
+        }
+        ctx.logger.info(`[AI] ${METADATA_TOOL_DEFINITIONS2.length} metadata tools registered as metadata`);
+        try {
+          const agentExists = typeof metadataService.exists === "function" ? await metadataService.exists("agent", METADATA_ASSISTANT_AGENT.name) : false;
+          if (!agentExists) {
+            await metadataService.register("agent", METADATA_ASSISTANT_AGENT.name, METADATA_ASSISTANT_AGENT);
+            console.log("[AI] Registered metadata_assistant agent to metadataService");
+            ctx.logger.info("[AI] metadata_assistant agent registered");
+          } else {
+            console.log("[AI] metadata_assistant agent already exists, skipping");
+            ctx.logger.debug("[AI] metadata_assistant agent already exists, skipping auto-registration");
+          }
+        } catch (err) {
+          ctx.logger.warn("[AI] Failed to register metadata_assistant agent", err instanceof Error ? { error: err.message, stack: err.stack } : { error: String(err) });
         }
       } catch (err) {
         ctx.logger.debug("[AI] Failed to register metadata tools", err instanceof Error ? err : void 0);
@@ -2554,14 +2770,15 @@ var AIServicePlugin = class {
     }
     await ctx.trigger("ai:ready", this.service);
     const routes = buildAIRoutes(this.service, this.service.conversationService, ctx.logger);
-    try {
-      const metadataService2 = ctx.getService("metadata");
-      if (metadataService2) {
-        const agentRuntime = new AgentRuntime(metadataService2);
-        const agentRoutes = buildAgentRoutes(this.service, agentRuntime, ctx.logger);
-        routes.push(...agentRoutes);
-      }
-    } catch {
+    const toolRoutes = buildToolRoutes(this.service, ctx.logger);
+    routes.push(...toolRoutes);
+    ctx.logger.info(`[AI] Tool routes registered (${toolRoutes.length} routes)`);
+    if (metadataService) {
+      const agentRuntime = new AgentRuntime(metadataService);
+      const agentRoutes = buildAgentRoutes(this.service, agentRuntime, ctx.logger);
+      routes.push(...agentRoutes);
+      ctx.logger.info(`[AI] Agent routes registered (${agentRoutes.length} routes)`);
+    } else {
       ctx.logger.debug("[AI] Metadata service not available, skipping agent routes");
     }
     await ctx.trigger("ai:routes", routes);
@@ -2577,6 +2794,11 @@ var AIServicePlugin = class {
     this.service = void 0;
   }
 };
+
+// src/index.ts
+init_data_tools();
+init_metadata_tools();
+init_metadata_tools();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIService,
@@ -2596,12 +2818,13 @@ var AIServicePlugin = class {
   addFieldTool,
   buildAIRoutes,
   buildAgentRoutes,
+  buildToolRoutes,
   createObjectTool,
   deleteFieldTool,
-  describeMetadataObjectTool,
+  describeObjectTool,
   encodeStreamPart,
   encodeVercelDataStream,
-  listMetadataObjectsTool,
+  listObjectsTool,
   modifyFieldTool,
   registerDataTools,
   registerMetadataTools