mirror of
https://github.com/bilawalsidhu/gods-eye-view.git
synced 2026-11-16 16:22:20 +00:00
Chat sits next to the mic in the command dock. Replies are silent and never request the microphone; the first message connects with the selected provider and runs the same map actions as voice through each provider's text API (OpenAI OPENAI_CHAT_MODEL, Gemini GEMINI_CHAT_MODEL via generateContent, which never starts Live). Only one mode runs at a time. - Chat panel rendered by the voice control presenter: conversation, recent and quick-command suggestions, Up/Down history, attachments (map-layer references or small UTF-8 text files, sent only with the message) - Chat and voice panels sit above the dock or dock into the right rail's column; minimized bars sit centred above the dock, and height animates on swaps - A centred panel steps down to its bar for the Location and Visual Presets trays without moving focus, rests above an open tray, and docks right while expanded over one; it returns to the centre once the trays close - Minimized voice previews the last sentence from each side; the empty Voice Preview suggests things to say - Settings opened from chat keep chat's frame and show the shared AI provider and quick commands; voice Settings show Back to voice - Closing chat ends a typed session; the voice panel's close turns voice off - The dock widens its voice control for the chat button and restyles its wings, which show icons only at 900px and below; assistant panels share the left panels' glass, and Cyber keeps its own surfaces - Server text-chat handlers with body, time and per-IP limits (GEV_RATELIMIT_*_CHAT_PER_MIN), documented in SECURITY.md; tests and all eleven locales Co-authored-by: Darren Dignam <[email protected]>
163 lines
4.7 KiB
JavaScript
163 lines
4.7 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { PassThrough } from 'node:stream';
|
|
import { EventEmitter } from 'node:events';
|
|
import { createGeminiChatHandler } from '../server/providers/gemini/chat.js';
|
|
const contents = [{ role: 'user', parts: [{ text: 'Hello' }] }];
|
|
async function request(input, overrides = {}) {
|
|
const calls = [];
|
|
const handler = createGeminiChatHandler({
|
|
resolveApiKey: () => 'fixture-key',
|
|
resolveRateLimit: () => '0',
|
|
resolveHost: () => '',
|
|
resolveAllowedHosts: () => '',
|
|
tools: [
|
|
{ name: 'fly_to', description: 'Fly', parameters: { type: 'object' } },
|
|
],
|
|
fetchImpl: async (url, options) => {
|
|
calls.push({ url, body: JSON.parse(options.body) });
|
|
return Response.json({
|
|
candidates: [
|
|
{
|
|
content: { role: 'model', parts: [{ text: 'Hello' }] },
|
|
finishReason: 'STOP',
|
|
},
|
|
],
|
|
});
|
|
},
|
|
...overrides,
|
|
});
|
|
const req = new PassThrough();
|
|
req.method = 'POST';
|
|
req.headers = {
|
|
host: 'localhost:4190',
|
|
origin: 'http://localhost:4190',
|
|
'content-type': 'application/json',
|
|
};
|
|
req.socket = { remoteAddress: '127.0.0.1' };
|
|
const res = new EventEmitter();
|
|
res.setHeader = () => {};
|
|
res.end = (body) => {
|
|
res.body = JSON.parse(body);
|
|
res.writableEnded = true;
|
|
};
|
|
const done = handler(req, res);
|
|
req.end(JSON.stringify(input));
|
|
await done;
|
|
return { calls, res };
|
|
}
|
|
test('Gemini chat pins text output, server tools and model without Live settings', async () => {
|
|
const { calls, res } = await request({ contents });
|
|
assert.equal(res.statusCode, 200);
|
|
assert.match(calls[0].url, /gemini-3.5-flash-lite:generateContent$/);
|
|
assert.deepEqual(calls[0].body.generationConfig.responseModalities, ['TEXT']);
|
|
assert.equal(
|
|
calls[0].body.tools[0].functionDeclarations[0].behavior,
|
|
undefined,
|
|
);
|
|
assert.equal(calls[0].body.outputAudioTranscription, undefined);
|
|
});
|
|
test('chat rejects caller configuration, media and undeclared tool history before upstream', async () => {
|
|
for (const input of [
|
|
{ contents, model: 'other' },
|
|
{ contents: [{ role: 'user', parts: [{ inlineData: { data: 'AA==' } }] }] },
|
|
{
|
|
contents: [
|
|
{
|
|
role: 'model',
|
|
parts: [{ functionCall: { name: 'not_allowed', args: {} } }],
|
|
},
|
|
],
|
|
},
|
|
]) {
|
|
const { calls, res } = await request(input);
|
|
assert.equal(res.statusCode, 400);
|
|
assert.equal(calls.length, 0);
|
|
}
|
|
});
|
|
test('chat refuses audio models and hides upstream errors', async () => {
|
|
const bad = await request(
|
|
{ contents },
|
|
{ resolveChatModel: () => 'gemini-3.8-live' },
|
|
);
|
|
assert.equal(bad.res.statusCode, 503);
|
|
assert.equal(bad.calls.length, 0);
|
|
const failure = await request(
|
|
{ contents },
|
|
{
|
|
fetchImpl: async () =>
|
|
new Response('sensitive upstream detail', { status: 500 }),
|
|
},
|
|
);
|
|
assert.equal(failure.res.statusCode, 502);
|
|
assert.ok(!JSON.stringify(failure.res.body).includes('sensitive'));
|
|
});
|
|
|
|
test('chat history round-trips signatures and function results while rejecting user signatures', async () => {
|
|
const exchange = [
|
|
...contents,
|
|
{
|
|
role: 'model',
|
|
parts: [
|
|
{
|
|
thoughtSignature: 'opaque',
|
|
functionCall: { name: 'fly_to', args: {}, id: 'call' },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
role: 'user',
|
|
parts: [
|
|
{
|
|
functionResponse: {
|
|
name: 'fly_to',
|
|
id: 'call',
|
|
response: { ok: true },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
];
|
|
const good = await request({ contents: exchange });
|
|
assert.equal(good.res.statusCode, 200);
|
|
assert.deepEqual(good.calls[0].body.contents, exchange);
|
|
const bad = await request({
|
|
contents: [
|
|
{ role: 'user', parts: [{ text: 'Hello', thoughtSignature: 'opaque' }] },
|
|
],
|
|
});
|
|
assert.equal(bad.res.statusCode, 400);
|
|
});
|
|
|
|
test('foreign and missing origins cannot spend the server key', async () => {
|
|
for (const origin of [undefined, 'https://elsewhere.example']) {
|
|
let calls = 0;
|
|
const handler = createGeminiChatHandler({
|
|
resolveHost: () => '',
|
|
resolveAllowedHosts: () => '',
|
|
fetchImpl: () => {
|
|
calls++;
|
|
throw Error('unexpected');
|
|
},
|
|
});
|
|
const req = new PassThrough();
|
|
req.method = 'POST';
|
|
req.headers = {
|
|
host: 'localhost:4190',
|
|
...(origin ? { origin } : {}),
|
|
'content-type': 'application/json',
|
|
};
|
|
req.socket = { remoteAddress: '127.0.0.1' };
|
|
const res = new EventEmitter();
|
|
res.setHeader = () => {};
|
|
res.end = () => {
|
|
res.writableEnded = true;
|
|
};
|
|
const done = handler(req, res);
|
|
req.end('{}');
|
|
await done;
|
|
assert.equal(res.statusCode, 403);
|
|
assert.equal(calls, 0);
|
|
}
|
|
});
|