@things-factory/ai-assistant 10.1.97 → 10.1.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-assistant",
-  "version": "10.1.97",
+  "version": "10.1.99",
   "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": "15e86d38824d6d2af94043eb14a928232a8924a3"
 }

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/data-entry.test.ts

@@ -309,3 +309,12 @@ describe('telling the application', () => {
     expect(result.proposed).toBe(true)
   })
 })
+
+describe('the card speaks the person\'s words', () => {
+  it('an enum field hands its value key prefix to the card - PERSONAL_CARD shows as the app\'s own word for it', async () => {
+    const target: EntryTarget = { ...expense, fields: [...expense.fields, { name: 'paidBy', type: 'enum', values: ['PERSONAL_CARD'], valueKeyPrefix: 'text.expense-payment-' }] }
+    const result: any = await proposeEntries(target, { rows: [{ values: { spentOn: '2026-09-12', amount: 1, paidBy: 'PERSONAL_CARD' }, sources: [{ where: 'x' }] }] }, { state: {} }, async () => new Map())
+    expect(result.columns.find((one: any) => one.name === 'paidBy')).toMatchObject({ valueKeyPrefix: 'text.expense-payment-' })
+  })
+})
+

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

@@ -28,6 +28,8 @@ export interface EntryField {
   labelKey?: string
   /** A number field the card sums - and compares with the total the material prints (§ totals). */
   total?: boolean
+  /** An enum's values on the card: `<prefix><value in lowercase>` - `text.expense-payment-` shows PERSONAL_CARD as 개인카드. */
+  valueKeyPrefix?: string
 }
 
 /** Where a row came from - which file, and where in it. Shown on the card beside the row. */

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',
@@ -44,7 +48,13 @@ function fieldSchema(field: EntryField): any {
 
 /** What the card needs besides the rows - the columns, in the target's order. */
 function columnsOf(target: EntryTarget) {
-  return target.fields.map(field => ({ name: field.name, type: field.type, required: !!field.required, ...(field.labelKey ? { labelKey: field.labelKey } : {}) }))
+  return target.fields.map(field => ({
+    name: field.name,
+    type: field.type,
+    required: !!field.required,
+    ...(field.labelKey ? { labelKey: field.labelKey } : {}),
+    ...(field.valueKeyPrefix ? { valueKeyPrefix: field.valueKeyPrefix } : {})
+  }))
 }
 
 export type SourceTextLoader = (attachmentIds: string[], context: any) => Promise<Map<string, string>>
@@ -205,7 +215,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/data-entry/entry-update.ts

@@ -125,7 +125,7 @@ function changedColumns(target: EntryTarget, rows: ChangeRow[]) {
   const used = new Set(rows.flatMap(row => Object.keys(row.values)))
   return changeableFields(target)
     .filter(field => used.has(field.name))
-    .map(field => ({ name: field.name, type: field.type, ...(field.labelKey ? { labelKey: field.labelKey } : {}) }))
+    .map(field => ({ name: field.name, type: field.type, ...(field.labelKey ? { labelKey: field.labelKey } : {}), ...(field.valueKeyPrefix ? { valueKeyPrefix: field.valueKeyPrefix } : {}) }))
 }
 
 export async function proposeChanges(target: EntryTarget, args: any, context: any, run: GraphqlRunner) {

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([])
+  })
 })