@things-factory/ai-assistant 10.1.97 → 10.1.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.97",
+  "version": "10.1.98",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh",
@@ -51,5 +51,5 @@
     "copyfiles": "^2.4.1",
     "rimraf": "^5.0.0"
   },
-  "gitHead": "79bebdf2ce31c5e82134757678be2cc1bb6e4dec"
+  "gitHead": "6321b11b694621c8cf7ba105650071eb88e9beb7"
 }

package/server/service/data-entry/data-entry-update.test.ts

@@ -190,3 +190,18 @@ describe('declaring and offering', () => {
     expect(rows[0].issues).toEqual([{ code: 'record-not-found', blocking: true }])
   })
 })
+
+describe('the tool schemas', () => {
+  /* Gemini's function schema refuses a list of types - one such field failed every office conversation (2026-10-01). */
+  const typesOf = (schema: any, path = ''): string[] =>
+    !schema || typeof schema !== 'object'
+      ? []
+      : [
+          ...(Array.isArray(schema.type) ? [`${path}: ${JSON.stringify(schema.type)}`] : []),
+          ...Object.entries(schema).flatMap(([key, value]) => (typeof value === 'object' ? typesOf(value, `${path}/${key}`) : []))
+        ]
+
+  it('★ every field has one type - no list of types anywhere in the tools', () => {
+    for (const spec of entryCategoryOf(expense, () => run).specs as any[]) expect(typesOf(spec.schema)).toEqual([])
+  })
+})

package/server/service/data-entry/entry-tools.ts

@@ -30,7 +30,11 @@ import {
 } from './entry-target.js'
 
 function fieldSchema(field: EntryField): any {
-  const type = field.type === 'number' || field.type === 'integer' ? ['number', 'string'] : field.type === 'boolean' ? ['boolean', 'string'] : 'string'
+  /*
+   * One type per field - Gemini's function schema (an OpenAPI 3.0 subset) refuses a list of types, and the
+   * whole request with it: "12,400" or "₩12,400" is the model's to write as 12400 (2026-10-01, office).
+   */
+  const type = field.type === 'number' ? 'number' : field.type === 'integer' ? 'integer' : field.type === 'boolean' ? 'boolean' : 'string'
   const said = [
     field.description,
     field.required ? 'required' : 'optional',
@@ -205,7 +209,7 @@ export function entryCategoryOf(target: EntryTarget, run: (context: any) => Grap
           description: 'The total the material itself prints, when it prints one - the card compares it with the sum of the rows. Never compute it yourself.',
           properties: {
             field: { type: 'string', description: `Which field it totals${target.fields.filter(field => field.total).length ? ` (${target.fields.filter(field => field.total).map(field => field.name).join(', ')})` : ''}.` },
-            value: { type: ['number', 'string'] },
+            value: { type: 'number' },
             attachmentId: { type: 'string' },
             where: { type: 'string' }
           }

package/server/service/workspace/workspace-blocks.ts

@@ -75,8 +75,15 @@ function block(raw: any): WorkspaceBlock {
       if (!columns.length) return unreadable(kind, 'no-columns')
       const given = Array.isArray(raw.rows) ? raw.rows : []
       /* A row is an object by column name, or an array in column order - models write both. */
+      /* A number column reads "12,400" as 12400 - cells come as text from a model told one type per field. */
+      const cell = (column: any, value: unknown) => {
+        const read = scalar(value)
+        if (column.type !== 'number' || typeof read !== 'string') return read
+        const number = Number(read.replace(/[,\s₩$€]/g, ''))
+        return read.trim() && Number.isFinite(number) ? number : read
+      }
       const rows = given.slice(0, MAX_TABLE_ROWS).map((row: any) =>
-        Object.fromEntries(columns.map((column: any, i: number) => [column.name, scalar(Array.isArray(row) ? row[i] : row?.[column.name])]))
+        Object.fromEntries(columns.map((column: any, i: number) => [column.name, cell(column, Array.isArray(row) ? row[i] : row?.[column.name])]))
       )
       return { kind, columns, rows, ...(text(raw.caption, 300) ? { caption: text(raw.caption, 300) } : {}), ...(given.length > MAX_TABLE_ROWS ? { cut: given.length - MAX_TABLE_ROWS } : {}) }
     }

package/server/service/workspace/workspace-tools.ts

@@ -41,9 +41,51 @@ const spec = {
       name: { type: 'string', description: 'A short key, lowercase with dashes ("contracts-by-customer"). The same name again makes a new version of the same workspace.' },
       title: { type: 'string' },
       summary: { type: 'string', description: 'One line under the title.' },
+      /*
+       * Every field of every block is declared, each with one type: Gemini's function schema (an OpenAPI 3.0
+       * subset) refuses a list of types and may leave out a field it was not told of (2026-10-01).
+       */
       blocks: {
         type: 'array',
-        items: { type: 'object', properties: { kind: { type: 'string', enum: [...WORKSPACE_BLOCK_KINDS] } }, required: ['kind'] }
+        items: {
+          type: 'object',
+          properties: {
+            kind: { type: 'string', enum: [...WORKSPACE_BLOCK_KINDS] },
+            text: { type: 'string', description: 'heading' },
+            level: { type: 'integer', description: 'heading: 1-3' },
+            markdown: { type: 'string', description: 'text' },
+            caption: { type: 'string', description: 'table, chart' },
+            unit: { type: 'string', description: 'chart' },
+            chart: { type: 'string', enum: ['bar', 'line'], description: 'chart' },
+            items: {
+              type: 'array',
+              description: 'metrics: {label,value,unit,note}; steps: {label,state,note}',
+              items: {
+                type: 'object',
+                properties: {
+                  label: { type: 'string' },
+                  value: { type: 'string' },
+                  unit: { type: 'string' },
+                  note: { type: 'string' },
+                  state: { type: 'string', enum: ['done', 'doing', 'todo', 'failed'] }
+                }
+              }
+            },
+            columns: {
+              type: 'array',
+              description: 'table',
+              items: { type: 'object', properties: { name: { type: 'string' }, label: { type: 'string' }, type: { type: 'string', enum: ['number', 'date', 'string'] } } }
+            },
+            rows: { type: 'array', description: 'table: each row is its cells in column order', items: { type: 'array', items: { type: 'string' } } },
+            x: { type: 'array', description: 'chart: the labels along the bottom', items: { type: 'string' } },
+            series: {
+              type: 'array',
+              description: 'chart',
+              items: { type: 'object', properties: { name: { type: 'string' }, values: { type: 'array', items: { type: 'number' } } } }
+            }
+          },
+          required: ['kind']
+        }
       }
     },
     required: ['name', 'title', 'blocks']

package/server/service/workspace/workspace.test.ts

@@ -55,4 +55,20 @@ describe('the workspace', () => {
     expect(showInWorkspace({ blocks: [{ kind: 'text', markdown: 'x' }] })).toMatchObject({ rejected: true, error: 'no-title' })
     expect(showInWorkspace({ title: 'x', blocks: [] })).toMatchObject({ rejected: true, error: 'no-blocks' })
   })
+
+  it('a number column reads the text a model writes - "12,400" is 12400, a word stays a word', () => {
+    const table: any = normalizeWorkspace({ title: 't', blocks: [{ kind: 'table', columns: [{ name: 'a', type: 'number' }], rows: [['12,400'], ['n/a']] }] }).workspace!.blocks[0]
+    expect(table.rows).toEqual([{ a: 12400 }, { a: 'n/a' }])
+  })
+
+  it('★ every field of the tool has one type, and every object says its fields - what Gemini accepts', () => {
+    const walk = (schema: any, path: string, out: string[]) => {
+      if (!schema || typeof schema !== 'object') return out
+      if (Array.isArray(schema.type)) out.push(`${path}: a list of types`)
+      if (schema.type === 'object' && !Object.keys(schema.properties ?? {}).length) out.push(`${path}: an object with no fields`)
+      for (const [key, value] of Object.entries(schema)) if (value && typeof value === 'object') walk(value, `${path}/${key}`, out)
+      return out
+    }
+    expect(walk((workspaceCategory.specs[0] as any).schema, '', [])).toEqual([])
+  })
 })