synthos 0.10.0 → 0.11.0

package/static-files/storage.v3.js

@@ -0,0 +1,176 @@
+/**
+ * storage.v3.js — Per-page and cross-page data & file storage
+ *
+ * Creates: synthos.data, synthos.files, synthos.shared
+ */
+(function() {
+    window.synthos = window.synthos || {};
+    if (window.__synthOSStorage) return;
+    window.__synthOSStorage = true;
+
+    var _json = window.synthos._json;
+    var _pageName = window.synthos._pageName;
+
+    // Fallback if server.v3.js hasn't loaded yet (defensive)
+    if (!_json) {
+        _json = function(method, url, body) {
+            var opts = { method: method, headers: { 'Content-Type': 'application/json' } };
+            if (body !== undefined) opts.body = JSON.stringify(body);
+            return fetch(url, opts).then(function(res) {
+                var ct = res.headers.get('content-type') || '';
+                var isJson = ct.indexOf('application/json') !== -1;
+                return (isJson ? res.json() : res.text()).then(function(data) {
+                    if (!res.ok) {
+                        if (res.status === 404 && isJson && data && data.error === 'table_not_found') return null;
+                        var err = new Error(isJson && data && data.error ? data.error : data);
+                        err.status = res.status;
+                        throw err;
+                    }
+                    return data;
+                });
+            });
+        };
+    }
+    if (!_pageName) {
+        _pageName = function() { return (window.pageInfo && window.pageInfo.name) || 'default'; };
+    }
+
+    function _pageData() {
+        return '/api/data/' + encodeURIComponent(_pageName());
+    }
+
+    window.synthos.data = {
+        list: function(table, opts) {
+            var url = _pageData() + '/' + encodeURIComponent(table);
+            if (opts && typeof opts.limit === 'number') {
+                url += '?limit=' + opts.limit;
+                if (typeof opts.offset === 'number') {
+                    url += '&offset=' + opts.offset;
+                }
+            }
+            return _json('GET', url) || [];
+        },
+        get: function(table, id) {
+            return _json('GET', _pageData() + '/' + encodeURIComponent(table) + '/' + encodeURIComponent(id)) || null;
+        },
+        save: function(table, row) {
+            return _json('POST', _pageData() + '/' + encodeURIComponent(table), row);
+        },
+        remove: function(table, id) {
+            return _json('DELETE', _pageData() + '/' + encodeURIComponent(table) + '/' + encodeURIComponent(id));
+        },
+        schema: function(table) {
+            return _json('GET', _pageData() + '/' + encodeURIComponent(table) + '/_schema').then(function(w) {
+                return w && w.schema ? w.schema : null;
+            });
+        },
+        defineSchema: function(table, schema, options) {
+            var merge = (options && options.merge === 'replace') ? 'replace' : 'additive';
+            var url = _pageData() + '/' + encodeURIComponent(table) + '/_schema?merge=' + merge;
+            var body = { schema: schema };
+            if (options && typeof options.definedBy === 'string') body.definedBy = options.definedBy;
+            return _json('PUT', url, body);
+        },
+        tables: function() {
+            return _json('GET', _pageData() + '/_tables').then(function(res) {
+                return (res && res.tables) || [];
+            });
+        }
+    };
+
+    window.synthos.files = {
+        list: function() {
+            return _json('GET', '/api/files/' + encodeURIComponent(_pageName()));
+        },
+        upload: function(filename, blob) {
+            return fetch('/api/files/' + encodeURIComponent(_pageName()), {
+                method: 'POST',
+                headers: { 'x-filename': filename },
+                body: blob
+            }).then(function(res) {
+                if (!res.ok) {
+                    return res.json().then(function(data) {
+                        var err = new Error(data && data.error ? data.error : 'Upload failed');
+                        err.status = res.status;
+                        throw err;
+                    });
+                }
+                return res.json();
+            });
+        },
+        url: function(filename) {
+            return '/api/files/' + encodeURIComponent(_pageName()) + '/' + encodeURIComponent(filename);
+        },
+        remove: function(filename) {
+            return _json('DELETE', '/api/files/' + encodeURIComponent(_pageName()) + '/' + encodeURIComponent(filename));
+        }
+    };
+
+    window.synthos.shared = {
+        data: {
+            list: function(table, opts) {
+                var url = '/api/shared/data/' + encodeURIComponent(table);
+                if (opts && typeof opts.limit === 'number') {
+                    url += '?limit=' + opts.limit;
+                    if (typeof opts.offset === 'number') {
+                        url += '&offset=' + opts.offset;
+                    }
+                }
+                return _json('GET', url) || [];
+            },
+            get: function(table, id) {
+                return _json('GET', '/api/shared/data/' + encodeURIComponent(table) + '/' + encodeURIComponent(id)) || null;
+            },
+            save: function(table, row) {
+                return _json('POST', '/api/shared/data/' + encodeURIComponent(table), row);
+            },
+            remove: function(table, id) {
+                return _json('DELETE', '/api/shared/data/' + encodeURIComponent(table) + '/' + encodeURIComponent(id));
+            },
+            schema: function(table) {
+                return _json('GET', '/api/shared/data/' + encodeURIComponent(table) + '/_schema').then(function(w) {
+                    return w && w.schema ? w.schema : null;
+                });
+            },
+            defineSchema: function(table, schema, options) {
+                var merge = (options && options.merge === 'replace') ? 'replace' : 'additive';
+                var url = '/api/shared/data/' + encodeURIComponent(table) + '/_schema?merge=' + merge;
+                var body = { schema: schema };
+                if (options && typeof options.definedBy === 'string') body.definedBy = options.definedBy;
+                return _json('PUT', url, body);
+            },
+            tables: function() {
+                return _json('GET', '/api/shared/data/_tables').then(function(res) {
+                    return (res && res.tables) || [];
+                });
+            }
+        },
+        files: {
+            list: function() {
+                return _json('GET', '/api/shared/files');
+            },
+            upload: function(filename, blob) {
+                return fetch('/api/shared/files', {
+                    method: 'POST',
+                    headers: { 'x-filename': filename },
+                    body: blob
+                }).then(function(res) {
+                    if (!res.ok) {
+                        return res.json().then(function(data) {
+                            var err = new Error(data && data.error ? data.error : 'Upload failed');
+                            err.status = res.status;
+                            throw err;
+                        });
+                    }
+                    return res.json();
+                });
+            },
+            url: function(filename) {
+                return '/api/shared/files/' + encodeURIComponent(filename);
+            },
+            remove: function(filename) {
+                return _json('DELETE', '/api/shared/files/' + encodeURIComponent(filename));
+            }
+        }
+    };
+})();

package/tests/anthropic.spec.ts

@@ -25,23 +25,23 @@ describe('buildAnthropicRequest', () => {
         assert.strictEqual(messages[2].content, 'Hello');
     });
 
-    it('appends assistant prefill "{" in jsonMode', () => {
+    it('ends on user message in jsonMode (4.6+ rejects assistant prefill)', () => {
         const args: PromptCompletionArgs = { ...baseArgs, jsonMode: true };
         const { messages } = buildAnthropicRequest(args, 0.0);
         const last = messages[messages.length - 1];
-        assert.strictEqual(last.role, 'assistant');
-        assert.strictEqual(last.content, '{');
+        assert.strictEqual(last.role, 'user');
+        assert.strictEqual(last.content, 'Hello');
     });
 
-    it('appends assistant prefill "{" when jsonSchema is provided', () => {
+    it('ends on user message when jsonSchema is provided', () => {
         const args: PromptCompletionArgs = { ...baseArgs, jsonSchema: { type: 'object' } };
         const { messages } = buildAnthropicRequest(args, 0.0);
         const last = messages[messages.length - 1];
-        assert.strictEqual(last.role, 'assistant');
-        assert.strictEqual(last.content, '{');
+        assert.strictEqual(last.role, 'user');
+        assert.strictEqual(last.content, 'Hello');
     });
 
-    it('does not prefill in plain text mode', () => {
+    it('ends on user message in plain text mode', () => {
         const { messages } = buildAnthropicRequest(baseArgs, 0.0);
         const last = messages[messages.length - 1];
         assert.strictEqual(last.role, 'user');
@@ -81,4 +81,39 @@ describe('buildAnthropicRequest', () => {
         const { temperature } = buildAnthropicRequest(args, 0.7);
         assert.strictEqual(temperature, 0.3);
     });
+
+    it('passes tools through to the request', () => {
+        const args: PromptCompletionArgs = {
+            ...baseArgs,
+            tools: [
+                {
+                    name: 'get_thing',
+                    description: 'Returns the thing.',
+                    input_schema: { type: 'object', properties: {}, additionalProperties: false },
+                },
+            ],
+        };
+        const { tools } = buildAnthropicRequest(args, 0.0);
+        assert.ok(tools);
+        assert.strictEqual(tools!.length, 1);
+        assert.strictEqual(tools![0].name, 'get_thing');
+        assert.strictEqual(tools![0].description, 'Returns the thing.');
+    });
+
+    it('returns no tools field when tools array is empty', () => {
+        const args: PromptCompletionArgs = { ...baseArgs, tools: [] };
+        const { tools } = buildAnthropicRequest(args, 0.0);
+        assert.strictEqual(tools, undefined);
+    });
+
+    it('disables JSON prefill when tools are provided', () => {
+        const args: PromptCompletionArgs = {
+            ...baseArgs,
+            jsonMode: true,
+            tools: [{ name: 't', description: 'd', input_schema: { type: 'object', properties: {}, additionalProperties: false } }],
+        };
+        const { messages } = buildAnthropicRequest(args, 0.0);
+        const last = messages[messages.length - 1];
+        assert.strictEqual(last.role, 'user', 'last message must be user when tools are bound (no "{" prefill)');
+    });
 });

package/tests/builders.spec.ts

@@ -1,8 +1,8 @@
 import assert from 'assert';
-import { createAnthropicBuilder, classifyRequest, buildWithModel } from '../src/builders/anthropic';
+import { createAnthropicBuilder, buildWithModel, TOOLS_INSTRUCTION_HINT } from '../src/builders/anthropic';
 import { createBuilder } from '../src/builders/index';
 import { ContextSection, BuilderResult } from '../src/builders/types';
-import { completePrompt, AgentCompletion } from '../src/models/types';
+import { completePrompt, AgentCompletion, PromptCompletionArgs, ToolDefinition, ToolHandler } from '../src/models/types';
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -13,6 +13,8 @@ const PAGE_HTML = '<html><body><h1>Hello</h1></body></html>';
 const currentPage: ContextSection = {
     title: '<CURRENT_PAGE>',
     content: PAGE_HTML,
+    sketch: null,
+    mode: 'always-full',
     instructions: '',
 };
 
@@ -46,7 +48,7 @@ describe('Anthropic Builder — Haiku Classifier Routing', () => {
 
             const builder = createAnthropicBuilder(tracker.fn, undefined, 'SynthOS', {
                 apiKey: 'test-key',
-                model: 'claude-sonnet-4-5-20250514',
+                model: 'claude-sonnet-4-6-20250514',
             });
 
             const result = await builder.run(currentPage, additionalSections, 'change heading', false);
@@ -103,6 +105,72 @@ describe('Anthropic Builder — Haiku Classifier Routing', () => {
                 assert.strictEqual(result.text, 'The heading says Hello.');
             }
         });
+
+        it('appends the tools instruction hint to system when tools are bound', async () => {
+            let captured: PromptCompletionArgs | undefined;
+            const complete: completePrompt = async (args) => {
+                captured = args;
+                return { completed: true, value: '[]' };
+            };
+            const tools: ToolDefinition[] = [{
+                name: 'get_thing',
+                description: 'Returns a thing.',
+                input_schema: { type: 'object', properties: {}, additionalProperties: false },
+            }];
+            const handlers: Record<string, ToolHandler> = { get_thing: async () => 'ok' };
+
+            await buildWithModel(complete, currentPage, additionalSections, 'test', undefined, 'SynthOS', undefined, undefined, tools, handlers);
+
+            assert.ok(captured);
+            assert.ok(captured!.system!.content.includes(TOOLS_INSTRUCTION_HINT), 'system should include tools hint');
+            assert.strictEqual(captured!.tools, tools);
+            assert.strictEqual(captured!.toolHandlers, handlers);
+        });
+
+        it('omits the tools instruction hint when tools are not bound', async () => {
+            let captured: PromptCompletionArgs | undefined;
+            const complete: completePrompt = async (args) => {
+                captured = args;
+                return { completed: true, value: '[]' };
+            };
+
+            await buildWithModel(complete, currentPage, additionalSections, 'test', undefined, 'SynthOS');
+
+            assert.ok(captured);
+            assert.ok(!captured!.system!.content.includes(TOOLS_INSTRUCTION_HINT), 'system must not include tools hint');
+            assert.strictEqual(captured!.tools, undefined);
+        });
+    });
+
+    describe('Builder.run() — tool passthrough', () => {
+        it('passes tools, toolHandlers, and onToolCall through to the model', async () => {
+            const changes = JSON.stringify([{ op: 'replace', nodeId: '1', html: '<h1>Hi</h1>' }]);
+            let captured: PromptCompletionArgs | undefined;
+            const complete: completePrompt = async (args) => {
+                captured = args;
+                return { completed: true, value: changes };
+            };
+
+            const tools: ToolDefinition[] = [{
+                name: 'get_connectors',
+                description: 'Returns connectors.',
+                input_schema: { type: 'object', properties: {}, additionalProperties: false },
+            }];
+            const handlers: Record<string, ToolHandler> = { get_connectors: async () => '[]' };
+            const onToolCall = (_names: string[]) => { /* noop */ };
+
+            const builder = createAnthropicBuilder(complete, undefined, 'SynthOS', {
+                apiKey: 'test-key',
+                model: 'claude-sonnet-4-6',
+            });
+            const result = await builder.run(currentPage, additionalSections, 'change', false, undefined, tools, handlers, onToolCall);
+
+            assert.strictEqual(result.kind, 'transforms');
+            assert.ok(captured);
+            assert.strictEqual(captured!.tools, tools);
+            assert.strictEqual(captured!.toolHandlers, handlers);
+            assert.strictEqual(captured!.onToolCall, onToolCall);
+        });
     });
 
     describe('createBuilder factory', () => {
@@ -113,7 +181,7 @@ describe('Anthropic Builder — Haiku Classifier Routing', () => {
             // Non-Opus model should just work without classification
             const builder = createBuilder('Anthropic', tracker.fn, undefined, 'SynthOS', {
                 apiKey: 'key',
-                model: 'claude-sonnet-4-5-20250514',
+                model: 'claude-sonnet-4-6-20250514',
             });
 
             const result = await builder.run(currentPage, additionalSections, 'test', false);