@objectstack/service-ai 4.0.1 → 4.0.3

package/dist/index.js

@@ -1,3 +1,759 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 });
+};
+
+// 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,
+  GET_RECORD_TOOL: () => GET_RECORD_TOOL,
+  QUERY_RECORDS_TOOL: () => QUERY_RECORDS_TOOL,
+  registerDataTools: () => registerDataTools
+});
+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
+      }
+    };
+    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
+      }
+    };
+    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"
+    ]);
+  }
+});
+
+// src/tools/create-object.tool.ts
+import { defineTool } from "@objectstack/spec/ai";
+var createObjectTool;
+var init_create_object_tool = __esm({
+  "src/tools/create-object.tool.ts"() {
+    "use strict";
+    createObjectTool = 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/add-field.tool.ts
+import { defineTool as defineTool2 } from "@objectstack/spec/ai";
+var addFieldTool;
+var init_add_field_tool = __esm({
+  "src/tools/add-field.tool.ts"() {
+    "use strict";
+    addFieldTool = defineTool2({
+      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
+      }
+    });
+  }
+});
+
+// src/tools/modify-field.tool.ts
+import { defineTool as defineTool3 } from "@objectstack/spec/ai";
+var modifyFieldTool;
+var init_modify_field_tool = __esm({
+  "src/tools/modify-field.tool.ts"() {
+    "use strict";
+    modifyFieldTool = defineTool3({
+      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
+      }
+    });
+  }
+});
+
+// src/tools/delete-field.tool.ts
+import { defineTool as defineTool4 } from "@objectstack/spec/ai";
+var deleteFieldTool;
+var init_delete_field_tool = __esm({
+  "src/tools/delete-field.tool.ts"() {
+    "use strict";
+    deleteFieldTool = defineTool4({
+      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/tools/list-objects.tool.ts
+import { defineTool as defineTool5 } from "@objectstack/spec/ai";
+var listObjectsTool;
+var init_list_objects_tool = __esm({
+  "src/tools/list-objects.tool.ts"() {
+    "use strict";
+    listObjectsTool = defineTool5({
+      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
+      }
+    });
+  }
+});
+
+// src/tools/describe-object.tool.ts
+import { defineTool as defineTool6 } from "@objectstack/spec/ai";
+var describeObjectTool;
+var init_describe_object_tool = __esm({
+  "src/tools/describe-object.tool.ts"() {
+    "use strict";
+    describeObjectTool = defineTool6({
+      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
+      }
+    });
+  }
+});
+
+// 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' });
+    }
+    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' });
+        }
+        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 } : {}
+    };
+    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.` });
+        }
+      }
+    }
+    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 } : {}
+    };
+    const updatedFields = { ...def.fields ?? {}, [name]: fieldDef };
+    await ctx.metadataService.register("object", objectName, {
+      ...def,
+      fields: updatedFields
+    });
+    return JSON.stringify({
+      objectName,
+      fieldName: name,
+      fieldType: type
+    });
+  };
+}
+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/ai-service.ts
 import { createLogger } from "@objectstack/core";
 
@@ -8,7 +764,9 @@ var MemoryLLMAdapter = class {
   }
   async chat(messages, options) {
     const lastUserMessage = [...messages].reverse().find((m) => m.role === "user");
-    const content = lastUserMessage ? `[memory] ${lastUserMessage.content}` : "[memory] (no user message)";
+    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",
@@ -26,10 +784,15 @@ var MemoryLLMAdapter = class {
     const result = await this.chat(messages);
     const words = result.content.split(" ");
     for (let i = 0; i < words.length; i++) {
-      const textDelta = i === 0 ? words[i] : ` ${words[i]}`;
-      yield { type: "text-delta", textDelta };
+      const wordText = i === 0 ? words[i] : ` ${words[i]}`;
+      yield { type: "text-delta", id: `delta_${i}`, text: wordText };
     }
-    yield { type: "finish", result };
+    yield {
+      type: "finish",
+      finishReason: "stop",
+      totalUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      rawFinishReason: "stop"
+    };
   }
   async embed(input) {
     const texts = Array.isArray(input) ? input : [input];
@@ -92,21 +855,34 @@ var ToolRegistry = class {
    * Execute a tool call and return the result.
    */
   async execute(toolCall) {
-    const handler = this.handlers.get(toolCall.name);
+    const handler = this.handlers.get(toolCall.toolName);
     if (!handler) {
       return {
-        toolCallId: toolCall.id,
-        content: `Tool "${toolCall.name}" is not registered`,
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: { type: "text", value: `Tool "${toolCall.toolName}" is not registered` },
         isError: true
       };
     }
     try {
-      const args = JSON.parse(toolCall.arguments);
+      const args = typeof toolCall.input === "string" ? JSON.parse(toolCall.input) : toolCall.input ?? {};
       const content = await handler(args);
-      return { toolCallId: toolCall.id, content };
+      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 { toolCallId: toolCall.id, content: message, isError: true };
+      return {
+        type: "tool-result",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        output: { type: "text", value: message },
+        isError: true
+      };
     }
   }
   /**
@@ -192,6 +968,17 @@ var InMemoryConversationService = class {
 };
 
 // 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();
@@ -219,8 +1006,8 @@ var _AIService = class _AIService {
     this.logger.debug("[AI] streamChat", { messageCount: messages.length, model: options?.model });
     if (!this.adapter.streamChat) {
       const result = await this.adapter.chat(messages, options);
-      yield { type: "text-delta", textDelta: result.content };
-      yield { type: "finish", result };
+      yield textDeltaPart("fallback", result.content);
+      yield finishPart(result);
       return;
     }
     yield* this.adapter.streamChat(messages, options);
@@ -237,6 +1024,10 @@ var _AIService = class _AIService {
     }
     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.
    *
@@ -277,23 +1068,26 @@ var _AIService = class _AIService {
       }
       this.logger.debug("[AI] chatWithTools tool calls", {
         iteration,
-        calls: result.toolCalls.map((tc) => tc.name)
+        calls: result.toolCalls.map((tc) => tc.toolName)
       });
+      const assistantContent = [];
+      if (result.content) assistantContent.push({ type: "text", text: result.content });
+      assistantContent.push(...result.toolCalls);
       conversation.push({
         role: "assistant",
-        content: result.content ?? "",
-        toolCalls: result.toolCalls
+        content: assistantContent
       });
       const toolResults = await this.toolRegistry.executeAll(result.toolCalls);
       for (const tr of toolResults) {
         if (tr.isError) {
-          const matchedCall = result.toolCalls.find((tc) => tc.id === tr.toolCallId);
-          const toolName = matchedCall?.name ?? "unknown";
-          const errorEntry = { iteration, toolName, error: tr.content };
+          const matchedCall = result.toolCalls.find((tc) => tc.toolCallId === tr.toolCallId);
+          const toolName = matchedCall?.toolName ?? "unknown";
+          const errorText = _AIService.extractOutputText(tr);
+          const errorEntry = { iteration, toolName, error: errorText };
           toolErrors.push(errorEntry);
           this.logger.warn("[AI] chatWithTools tool error", errorEntry);
           if (onToolError && matchedCall) {
-            const action = onToolError(matchedCall, tr.content);
+            const action = onToolError(matchedCall, errorText);
             if (action === "abort") {
               abortedByCallback = true;
             }
@@ -301,8 +1095,7 @@ var _AIService = class _AIService {
         }
         conversation.push({
           role: "tool",
-          content: tr.content,
-          toolCallId: tr.toolCallId
+          content: [tr]
         });
       }
       if (abortedByCallback) {
@@ -348,33 +1141,41 @@ var _AIService = class _AIService {
     for (let iteration = 0; iteration < maxIterations; iteration++) {
       const result2 = await this.adapter.chat(conversation, chatOptions);
       if (!result2.toolCalls || result2.toolCalls.length === 0) {
-        yield { type: "text-delta", textDelta: result2.content };
-        yield { type: "finish", result: result2 };
+        yield textDeltaPart("stream", result2.content);
+        yield finishPart(result2);
         return;
       }
       for (const tc of result2.toolCalls) {
-        yield { type: "tool-call", toolCall: tc };
+        yield { type: "tool-call", toolCallId: tc.toolCallId, toolName: tc.toolName, input: tc.input };
       }
+      const assistantContent = [];
+      if (result2.content) assistantContent.push({ type: "text", text: result2.content });
+      assistantContent.push(...result2.toolCalls);
       conversation.push({
         role: "assistant",
-        content: result2.content ?? "",
-        toolCalls: result2.toolCalls
+        content: assistantContent
       });
       const toolResults = await this.toolRegistry.executeAll(result2.toolCalls);
       for (const tr of toolResults) {
         if (tr.isError && onToolError) {
-          const matchedCall = result2.toolCalls.find((tc) => tc.id === tr.toolCallId);
+          const matchedCall = result2.toolCalls.find((tc) => tc.toolCallId === tr.toolCallId);
           if (matchedCall) {
-            const action = onToolError(matchedCall, tr.content);
+            const errorText = _AIService.extractOutputText(tr);
+            const action = onToolError(matchedCall, errorText);
             if (action === "abort") {
               abortedByCallback = true;
             }
           }
         }
+        yield {
+          type: "tool-result",
+          toolCallId: tr.toolCallId,
+          toolName: tr.toolName,
+          output: tr.output
+        };
         conversation.push({
           role: "tool",
-          content: tr.content,
-          toolCallId: tr.toolCallId
+          content: [tr]
         });
       }
       if (abortedByCallback) {
@@ -388,8 +1189,8 @@ var _AIService = class _AIService {
     }
     const finalOptions = { ...chatOptions, tools: void 0, toolChoice: void 0 };
     const result = await this.adapter.chat(conversation, finalOptions);
-    yield { type: "text-delta", textDelta: result.content };
-    yield { type: "finish", result };
+    yield textDeltaPart("stream", result.content);
+    yield finishPart(result);
   }
 };
 // ── Tool Call Loop ────────────────────────────────────────────
@@ -397,6 +1198,143 @@ var _AIService = class _AIService {
 _AIService.DEFAULT_MAX_ITERATIONS = 10;
 var AIService = _AIService;
 
+// src/stream/vercel-stream-encoder.ts
+function sse(data) {
+  return `data: ${JSON.stringify(data)}
+
+`;
+}
+function dataStreamLine(prefix, data) {
+  return `${prefix}:${JSON.stringify(data)}
+`;
+}
+function encodeStreamPart(part) {
+  switch (part.type) {
+    case "text-delta":
+      return sse({ type: "text-delta", id: "0", delta: part.text });
+    case "tool-input-start":
+      return sse({
+        type: "tool-input-start",
+        toolCallId: part.id,
+        toolName: part.toolName
+      });
+    case "tool-input-delta":
+      return sse({
+        type: "tool-input-delta",
+        toolCallId: part.id,
+        inputTextDelta: part.delta
+      });
+    case "tool-call":
+      return sse({
+        type: "tool-input-available",
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        input: part.input
+      });
+    case "tool-result":
+      return sse({
+        type: "tool-output-available",
+        toolCallId: part.toolCallId,
+        output: part.output
+      });
+    case "error":
+      return sse({
+        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 "";
+  }
+}
+async function* encodeVercelDataStream(events) {
+  yield sse({ type: "start" });
+  yield sse({ type: "start-step" });
+  yield sse({ type: "text-start", id: "0" });
+  let textOpen = true;
+  let finishReason = "stop";
+  for await (const part of events) {
+    if (part.type === "finish") {
+      finishReason = part.finishReason ?? "stop";
+    }
+    if (part.type === "finish-step" || part.type === "finish") {
+      if (textOpen) {
+        yield sse({ type: "text-end", id: "0" });
+        textOpen = false;
+      }
+      continue;
+    }
+    const frame = encodeStreamPart(part);
+    if (frame) {
+      yield frame;
+    }
+  }
+  if (textOpen) {
+    yield sse({ type: "text-end", id: "0" });
+  }
+  yield sse({ type: "finish-step" });
+  yield sse({ type: "finish", finishReason });
+  yield "data: [DONE]\n\n";
+}
+
+// src/routes/message-utils.ts
+function normalizeMessage(raw) {
+  const role = raw.role;
+  if (typeof raw.content === "string") {
+    return { role, content: raw.content };
+  }
+  if (Array.isArray(raw.content)) {
+    return { role, content: raw.content };
+  }
+  if (Array.isArray(raw.parts)) {
+    const textParts = raw.parts.filter((p) => p.type === "text" && typeof p.text === "string").map((p) => p.text);
+    if (textParts.length > 0) {
+      return { role, content: textParts.join("") };
+    }
+  }
+  return { role, content: "" };
+}
+function validateMessageContent(msg, opts) {
+  const content = msg.content;
+  if (Array.isArray(msg.parts)) {
+    return null;
+  }
+  if (typeof content === "string") {
+    return null;
+  }
+  if (Array.isArray(content)) {
+    for (const part of content) {
+      if (typeof part !== "object" || part === null) {
+        return "message.content array elements must be non-null objects";
+      }
+      const partObj = part;
+      if (typeof partObj.type !== "string") {
+        return 'each message.content array element must have a string "type" property';
+      }
+      if (partObj.type === "text" && typeof partObj.text !== "string") {
+        return 'message.content elements with type "text" must have a string "text" property';
+      }
+    }
+    return null;
+  }
+  if ((content === null || content === void 0) && opts?.allowEmptyContent) {
+    return null;
+  }
+  return "message.content must be a string, an array, or include parts";
+}
+
 // src/routes/ai-routes.ts
 var VALID_ROLES = /* @__PURE__ */ new Set(["system", "user", "assistant", "tool"]);
 function validateMessage(raw) {
@@ -407,22 +1345,30 @@ function validateMessage(raw) {
   if (typeof msg.role !== "string" || !VALID_ROLES.has(msg.role)) {
     return `message.role must be one of ${[...VALID_ROLES].map((r) => `"${r}"`).join(", ")}`;
   }
-  if (typeof msg.content !== "string") {
-    return "message.content must be a string";
-  }
-  return null;
+  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)
+    //   • `stream === false`  → JSON response (legacy)
+    //
     {
       method: "POST",
       path: "/api/v1/ai/chat",
-      description: "Synchronous chat completion",
+      description: "Chat completion (supports Vercel AI Data Stream Protocol)",
       auth: true,
       permissions: ["ai:chat"],
       handler: async (req) => {
-        const { messages, options } = req.body ?? {};
+        const body = req.body ?? {};
+        const messages = body.messages;
         if (!Array.isArray(messages) || messages.length === 0) {
           return { status: 400, body: { error: "messages array is required" } };
         }
@@ -430,8 +1376,49 @@ function buildAIRoutes(aiService, conversationService, logger) {
           const err = validateMessage(msg);
           if (err) return { status: 400, body: { error: err } };
         }
+        const nested = body.options ?? {};
+        const resolvedOptions = {
+          ...nested,
+          ...body.model != null && { model: body.model },
+          ...body.temperature != null && { temperature: body.temperature },
+          ...body.maxTokens != null && { maxTokens: body.maxTokens }
+        };
+        const rawSystemPrompt = body.system ?? body.systemPrompt;
+        if (rawSystemPrompt != null && typeof rawSystemPrompt !== "string") {
+          return { status: 400, body: { error: "system/systemPrompt must be a string" } };
+        }
+        const systemPrompt = rawSystemPrompt;
+        const finalMessages = [
+          ...systemPrompt ? [{ role: "system", content: systemPrompt }] : [],
+          ...messages.map((m) => normalizeMessage(m))
+        ];
+        const wantStream = body.stream !== false;
+        if (wantStream) {
+          try {
+            if (!aiService.streamChatWithTools) {
+              return { status: 501, body: { error: "Streaming is not supported by the configured AI service" } };
+            }
+            const events = aiService.streamChatWithTools(finalMessages, resolvedOptions);
+            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)
+            };
+          } catch (err) {
+            logger.error("[AI Route] /chat stream error", err instanceof Error ? err : void 0);
+            return { status: 500, body: { error: "Internal AI service error" } };
+          }
+        }
         try {
-          const result = await aiService.chat(messages, options);
+          const result = await aiService.chatWithTools(finalMessages, resolvedOptions);
           return { status: 200, body: result };
         } catch (err) {
           logger.error("[AI Route] /chat error", err instanceof Error ? err : void 0);
@@ -459,7 +1446,7 @@ function buildAIRoutes(aiService, conversationService, logger) {
           if (!aiService.streamChat) {
             return { status: 501, body: { error: "Streaming is not supported by the configured AI service" } };
           }
-          const events = aiService.streamChat(messages, options);
+          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);
@@ -637,17 +1624,41 @@ function validateAgentMessage(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;
+  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" } };
+        }
+      }
+    },
+    // ── 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",
+      description: "Chat with a specific AI agent (supports Vercel AI Data Stream Protocol)",
       auth: true,
       permissions: ["ai:chat", "ai:agents"],
       handler: async (req) => {
@@ -655,11 +1666,12 @@ function buildAgentRoutes(aiService, agentRuntime, logger) {
         if (!agentName) {
           return { status: 400, body: { error: "agentName parameter is required" } };
         }
+        const body = req.body ?? {};
         const {
           messages: rawMessages,
           context: chatContext,
           options: extraOptions
-        } = req.body ?? {};
+        } = body;
         if (!Array.isArray(rawMessages) || rawMessages.length === 0) {
           return { status: 400, body: { error: "messages array is required" } };
         }
@@ -687,21 +1699,150 @@ function buildAgentRoutes(aiService, agentRuntime, logger) {
               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" } };
+        }
+      }
+    }
+  ];
+}
+
+// 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
+              }
+            };
           }
-          const mergedOptions = { ...agentOptions, ...safeOverrides };
-          const fullMessages = [
-            ...systemMessages,
-            ...rawMessages
-          ];
-          const result = await aiService.chatWithTools(fullMessages, {
-            ...mergedOptions,
-            maxIterations: agent.planning?.maxIterations
-          });
-          return { status: 200, body: result };
+          return {
+            status: 200,
+            body: {
+              result: extractOutputValue(result.output),
+              duration,
+              toolName
+            }
+          };
         } catch (err) {
           logger.error(
-            "[AI Route] /agents/:agentName/chat error",
+            "[AI Route] /tools/:toolName/execute error",
             err instanceof Error ? err : void 0
           );
           return { status: 500, body: { error: "Internal AI service error" } };
@@ -803,13 +1944,35 @@ var ObjectQLConversationService = class {
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const msgId = `msg_${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: message.content,
-      tool_calls: message.toolCalls ? JSON.stringify(message.toolCalls) : null,
-      tool_call_id: message.toolCallId ?? null,
+      content: contentStr,
+      tool_calls: toolCallsJson,
+      tool_call_id: toolCallId,
       created_at: now
     });
     await this.engine.update(CONVERSATIONS_OBJECT, { id: conversationId, updated_at: now }, {
@@ -854,21 +2017,42 @@ var ObjectQLConversationService = class {
     };
   }
   /**
-   * Map a database row to an AIMessage.
+   * Map a database row to a ModelMessage.
    */
   toMessage(row) {
-    const msg = {
-      role: row.role,
-      content: row.content
-    };
-    const toolCalls = this.safeParse(row.tool_calls);
-    if (toolCalls) {
-      msg.toolCalls = toolCalls;
-    }
-    if (row.tool_call_id) {
-      msg.toolCallId = row.tool_call_id;
+    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 };
     }
-    return msg;
   }
 };
 
@@ -1007,263 +2191,9 @@ var AiMessageObject = ObjectSchema2.create({
   }
 });
 
-// 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"] }
-          }
-        },
-        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
-  }
-};
-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)"
-      }
-    },
-    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"
-      }
-    },
-    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/plugin.ts
+init_data_tools();
+init_metadata_tools();
 
 // src/agent-runtime.ts
 import { AgentSchema } from "@objectstack/spec/ai";
@@ -1272,6 +2202,27 @@ var AgentRuntime = class {
     this.metadataService = metadataService;
   }
   // ── Public API ────────────────────────────────────────────────
+  /**
+   * List all active agents registered in the metadata service.
+   *
+   * Returns a summary for each agent (name, label, role) suitable
+   * for populating an agent selector dropdown in the UI.
+   */
+  async listAgents() {
+    const rawItems = await this.metadataService.list("agent");
+    const agents = [];
+    for (const raw of rawItems) {
+      const result = AgentSchema.safeParse(raw);
+      if (result.success && result.data.active) {
+        agents.push({
+          name: result.data.name,
+          label: result.data.label,
+          role: result.data.role
+        });
+      }
+    }
+    return agents;
+  }
   /**
    * Load and validate an agent definition by name.
    *
@@ -1400,15 +2351,233 @@ Guidelines:
   }
 };
 
+// src/agents/metadata-assistant-agent.ts
+var METADATA_ASSISTANT_AGENT = {
+  name: "metadata_assistant",
+  label: "Metadata Assistant",
+  role: "Schema Architect",
+  instructions: `You are an expert metadata architect that helps users design and manage their data models through natural language.
+
+Capabilities:
+- Create new data objects (tables) with fields
+- Add fields (columns) to existing objects
+- Modify field properties (label, type, required, default value)
+- Delete fields from objects
+- List all registered metadata objects and their schemas
+- Describe the full schema of a specific object
+
+Guidelines:
+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.
+6. Explain what changes you are about to make before executing them.
+7. After making changes, confirm the result by describing the updated schema.
+8. For destructive operations (deleting fields), always warn the user about potential data loss.
+9. Always answer in the same language the user is using.
+10. If the user's request is ambiguous, ask clarifying questions before proceeding.`,
+  model: {
+    provider: "openai",
+    model: "gpt-4",
+    temperature: 0.2,
+    maxTokens: 4096
+  },
+  tools: [
+    { type: "action", name: "create_object", description: "Create a new data object (table)" },
+    { 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_objects", description: "List all data objects" },
+    { type: "query", name: "describe_object", description: "Describe an object schema" }
+  ],
+  active: true,
+  visibility: "global",
+  guardrails: {
+    maxTokensPerInvocation: 8192,
+    maxExecutionTimeSec: 60,
+    blockedTopics: ["drop_database", "raw_sql", "system_tables"]
+  },
+  planning: {
+    strategy: "react",
+    maxIterations: 10,
+    allowReplan: true
+  },
+  memory: {
+    shortTerm: {
+      maxMessages: 30,
+      maxTokens: 8192
+    }
+  }
+};
+
+// src/adapters/vercel-adapter.ts
+import { generateText, streamText, tool as vercelTool, jsonSchema } from "ai";
+function buildVercelOptions(options) {
+  if (!options) return {};
+  const opts = {};
+  if (options.temperature != null) opts.temperature = options.temperature;
+  if (options.maxTokens != null) opts.maxTokens = options.maxTokens;
+  if (options.stop?.length) opts.stopSequences = options.stop;
+  if (options.tools?.length) {
+    const tools = {};
+    for (const t of options.tools) {
+      tools[t.name] = vercelTool({
+        description: t.description,
+        inputSchema: jsonSchema(t.parameters)
+      });
+    }
+    opts.tools = tools;
+  }
+  if (options.toolChoice != null) {
+    opts.toolChoice = options.toolChoice;
+  }
+  return opts;
+}
+var VercelLLMAdapter = class {
+  constructor(config) {
+    this.name = "vercel";
+    this.model = config.model;
+  }
+  async chat(messages, options) {
+    const result = await generateText({
+      model: this.model,
+      messages,
+      ...buildVercelOptions(options)
+    });
+    return {
+      content: result.text,
+      model: result.response?.modelId,
+      toolCalls: result.toolCalls?.length ? result.toolCalls : void 0,
+      usage: result.usage ? {
+        promptTokens: result.usage.inputTokens ?? 0,
+        completionTokens: result.usage.outputTokens ?? 0,
+        totalTokens: result.usage.totalTokens ?? 0
+      } : void 0
+    };
+  }
+  async complete(prompt, options) {
+    const result = await generateText({
+      model: this.model,
+      prompt,
+      ...buildVercelOptions(options)
+    });
+    return {
+      content: result.text,
+      model: result.response?.modelId,
+      usage: result.usage ? {
+        promptTokens: result.usage.inputTokens ?? 0,
+        completionTokens: result.usage.outputTokens ?? 0,
+        totalTokens: result.usage.totalTokens ?? 0
+      } : void 0
+    };
+  }
+  async *streamChat(messages, options) {
+    const result = streamText({
+      model: this.model,
+      messages,
+      ...buildVercelOptions(options)
+    });
+    for await (const part of result.fullStream) {
+      yield part;
+    }
+  }
+  async embed(_input) {
+    throw new Error(
+      "[VercelLLMAdapter] Embeddings require a dedicated EmbeddingModel. Configure an embedding adapter instead."
+    );
+  }
+  async listModels() {
+    return [];
+  }
+};
+
 // src/plugin.ts
 var AIServicePlugin = class {
   constructor(options = {}) {
     this.name = "com.objectstack.service-ai";
     this.version = "1.0.0";
     this.type = "standard";
-    this.dependencies = [];
+    this.dependencies = ["com.objectstack.engine.objectql"];
     this.options = options;
   }
+  /**
+   * Auto-detect LLM provider from environment variables.
+   *
+   * Priority order:
+   * 1. AI_GATEWAY_MODEL → Vercel AI Gateway
+   * 2. OPENAI_API_KEY → OpenAI
+   * 3. ANTHROPIC_API_KEY → Anthropic
+   * 4. GOOGLE_GENERATIVE_AI_API_KEY → Google
+   * 5. Fallback → MemoryLLMAdapter
+   *
+   * Returns the adapter and a description for logging.
+   */
+  async detectAdapter(ctx) {
+    const gatewayModel = process.env.AI_GATEWAY_MODEL;
+    if (gatewayModel) {
+      try {
+        const gatewayPkg = "@ai-sdk/gateway";
+        const { gateway } = await import(
+          /* webpackIgnore: true */
+          gatewayPkg
+        );
+        const adapter = new VercelLLMAdapter({ model: gateway(gatewayModel) });
+        return { adapter, description: `Vercel AI Gateway (model: ${gatewayModel})` };
+      } catch (err) {
+        ctx.logger.warn(
+          `[AI] Failed to load @ai-sdk/gateway for AI_GATEWAY_MODEL=${gatewayModel}, trying next provider`,
+          err instanceof Error ? { error: err.message } : void 0
+        );
+      }
+    }
+    const providerConfigs = [
+      {
+        envKey: "OPENAI_API_KEY",
+        pkg: "@ai-sdk/openai",
+        factory: "openai",
+        defaultModel: "gpt-4o",
+        displayName: "OpenAI"
+      },
+      {
+        envKey: "ANTHROPIC_API_KEY",
+        pkg: "@ai-sdk/anthropic",
+        factory: "anthropic",
+        defaultModel: "claude-sonnet-4-20250514",
+        displayName: "Anthropic"
+      },
+      {
+        envKey: "GOOGLE_GENERATIVE_AI_API_KEY",
+        pkg: "@ai-sdk/google",
+        factory: "google",
+        defaultModel: "gemini-2.0-flash",
+        displayName: "Google"
+      }
+    ];
+    for (const { envKey, pkg, factory, defaultModel, displayName } of providerConfigs) {
+      if (process.env[envKey]) {
+        try {
+          const mod = await import(
+            /* webpackIgnore: true */
+            pkg
+          );
+          const createModel = mod[factory] ?? mod.default;
+          if (typeof createModel === "function") {
+            const modelId = process.env.AI_MODEL ?? defaultModel;
+            const adapter = new VercelLLMAdapter({ model: createModel(modelId) });
+            return { adapter, description: `${displayName} (model: ${modelId})` };
+          }
+        } catch (err) {
+          ctx.logger.warn(
+            `[AI] Failed to load ${pkg} for ${envKey}, trying next provider`,
+            err instanceof Error ? { error: err.message } : void 0
+          );
+        }
+      }
+    }
+    ctx.logger.warn("[AI] No LLM provider configured via environment variables. Falling back to MemoryLLMAdapter (echo mode). Set AI_GATEWAY_MODEL, OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_GENERATIVE_AI_API_KEY to use a real LLM.");
+    return { adapter: new MemoryLLMAdapter(), description: "MemoryLLMAdapter (echo mode - for testing only)" };
+  }
   async init(ctx) {
     let hasExisting = false;
     try {
@@ -1430,8 +2599,19 @@ var AIServicePlugin = class {
       } catch {
       }
     }
+    let adapter;
+    let adapterDescription;
+    if (this.options.adapter) {
+      adapter = this.options.adapter;
+      adapterDescription = `${adapter.name} (explicitly configured)`;
+    } else {
+      const detected = await this.detectAdapter(ctx);
+      adapter = detected.adapter;
+      adapterDescription = detected.description;
+    }
+    ctx.logger.info(`[AI] Using LLM adapter: ${adapterDescription}`);
     const config = {
-      adapter: this.options.adapter,
+      adapter,
       logger: ctx.logger,
       conversationService
     };
@@ -1441,7 +2621,7 @@ var AIServicePlugin = class {
     } else {
       ctx.registerService("ai", this.service);
     }
-    ctx.registerService("app.com.objectstack.service-ai", {
+    ctx.getService("manifest").register({
       id: "com.objectstack.service-ai",
       name: "AI Service",
       version: "1.0.0",
@@ -1454,40 +2634,113 @@ var AIServicePlugin = class {
         ctx.logger.debug("[AI] Before chat", { messages });
       });
     }
+    try {
+      const setupNav = ctx.getService("setupNav");
+      if (setupNav) {
+        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 }
+          ]
+        });
+        ctx.logger.info("[AI] Navigation items contributed to Setup App");
+      }
+    } catch {
+    }
     ctx.logger.info("[AI] Service initialized");
   }
   async start(ctx) {
     if (!this.service) return;
+    let metadataService;
+    try {
+      metadataService = ctx.getService("metadata");
+      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");
-      const metadataService = ctx.getService("metadata");
-      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 {
-      ctx.logger.debug("[AI] Data engine or metadata service not available, skipping data tools");
+      ctx.logger.debug("[AI] Data engine not available, skipping data tools");
+    }
+    if (metadataService) {
+      try {
+        registerMetadataTools(this.service.toolRegistry, { metadataService });
+        ctx.logger.info("[AI] Built-in metadata tools registered");
+        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);
+      }
     }
     await ctx.trigger("ai:ready", this.service);
     const routes = buildAIRoutes(this.service, this.service.conversationService, ctx.logger);
-    try {
-      const metadataService = ctx.getService("metadata");
-      if (metadataService) {
-        const agentRuntime = new AgentRuntime(metadataService);
-        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);
+    const kernel = ctx.getKernel();
+    if (kernel) {
+      kernel.__aiRoutes = routes;
+    }
     ctx.logger.info(
       `[AI] Service started \u2014 adapter="${this.service.adapterName}", tools=${this.service.toolRegistry.size}, routes=${routes.length}`
     );
@@ -1496,6 +2749,11 @@ var AIServicePlugin = class {
     this.service = void 0;
   }
 };
+
+// src/index.ts
+init_data_tools();
+init_metadata_tools();
+init_metadata_tools();
 export {
   AIService,
   AIServicePlugin,
@@ -1505,11 +2763,24 @@ export {
   DATA_CHAT_AGENT,
   DATA_TOOL_DEFINITIONS,
   InMemoryConversationService,
+  METADATA_ASSISTANT_AGENT,
+  METADATA_TOOL_DEFINITIONS,
   MemoryLLMAdapter,
   ObjectQLConversationService,
   ToolRegistry,
+  VercelLLMAdapter,
+  addFieldTool,
   buildAIRoutes,
   buildAgentRoutes,
-  registerDataTools
+  buildToolRoutes,
+  createObjectTool,
+  deleteFieldTool,
+  describeObjectTool,
+  encodeStreamPart,
+  encodeVercelDataStream,
+  listObjectsTool,
+  modifyFieldTool,
+  registerDataTools,
+  registerMetadataTools
 };
 //# sourceMappingURL=index.js.map