Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
import { get } from 'svelte/store';
import { controller, params, toolSchema, knowledgeSkills } from './stores.js';
import { headersForFetch, providers } from './providers.js';
import { serializeToolCallArguments } from './util.js';
const KNOWLEDGE_SOFT_CAP = 60_000;
function buildKnowledgeBlock() {
const skills = get(knowledgeSkills) || [];
if (!skills.length) return '';
const blocks = skills
.map((s) => `## Skill: ${s.name}\n${(s.content || '').trim()}`)
.join('\n\n---\n\n');
const total = blocks.length;
if (total > KNOWLEDGE_SOFT_CAP) {
console.warn(
`[knowledgeSkills] content size ${total} chars exceeds soft cap ${KNOWLEDGE_SOFT_CAP} (${skills.length} skills); sending in full`
);
}
return `\n\n# Installed knowledge skills\n\nThe user has activated the following skills. Apply them when relevant.\n\n${blocks}`;
}
export async function complete(convo, onupdate, onabort) {
try {
controller.set(new AbortController());
const model = convo.models[0];
const param = get(params);
const openAICompatibleFormat =
model.provider === 'OpenAI' ||
model.provider === 'OpenRouter' ||
model.provider === 'Groq' ||
model.provider === 'Mistral' ||
model.provider === 'Built-in';
let messages = convo.messages.map(
openAICompatibleFormat ? messageToOpenAIFormat : messageToAnthropicFormat
);
if (convo.retrievalContext) {
const contextBlock = `\n\n---\nRelevant context from knowledge base:\n${convo.retrievalContext}\n---\n`;
const sysIdx = messages.findIndex((m) => m.role === 'system');
if (sysIdx !== -1) {
messages[sysIdx] = { ...messages[sysIdx], content: messages[sysIdx].content + contextBlock };
} else {
messages.unshift({ role: 'system', content: `Relevant context:\n${convo.retrievalContext}` });
}
}
const knowledgeBlock = buildKnowledgeBlock();
if (knowledgeBlock) {
const sysIdx = messages.findIndex((m) => m.role === 'system');
if (sysIdx !== -1) {
messages[sysIdx] = {
...messages[sysIdx],
content: messages[sysIdx].content + knowledgeBlock,
};
} else {
messages.unshift({ role: 'system', content: knowledgeBlock.trimStart() });
}
}
let system = undefined;
if (model.provider === 'Anthropic' && messages[0]?.role === 'system') {
system = messages.shift().content;
}
if (param.messagesContextLimit > 0) {
messages = limitMessagesContext(messages, param.messagesContextLimit);
}
// Drop a trailing unclosed, empty assistant message so we never submit a
// dangling turn, and it applies across every provider, Anthropic included.
if (
convo.messages[convo.messages.length - 1].unclosed &&
convo.messages[convo.messages.length - 1].content === ''
) {
messages.pop();
}
const schema = get(toolSchema)
.map((group) => group.schema)
.flat();
const activeSchema = schema
.filter((tool) => (convo.tools || []).includes(tool.function.name))
.map((tool) => {
if (model.provider === 'Anthropic') {
return toolSchemaToAnthropicFormat(tool);
}
return {
type: tool.type,
function: tool.function,
};
});
const provider = providers.find((p) => p.name === model.provider);
const stream = model.id !== 'o1';
const completions = async (signal) => {
return fetch(`${provider.url}${provider.completionUrl}`, {
method: 'POST',
headers: headersForFetch(provider, model),
signal,
body: JSON.stringify({
stream,
model: model.id,
temperature:
model.temperatureUnsupported ||
(model.provider === 'Anthropic' &&
model.kind === 'reasoner' &&
param.reasoningEffort['range'] > 0)
? undefined
: param.temperature,
...(model.provider === 'OpenAI' && model.kind === 'reasoner'
? {
max_completion_tokens:
param.maxTokens != null && param.maxTokens > 0 ? param.maxTokens : undefined,
}
: {
max_tokens:
param.maxTokens != null && param.maxTokens > 0
? param.maxTokens
: model.provider === 'Anthropic'
? model.maxTokensDefault || 4096
: undefined,
}),
tools: activeSchema.length > 0 ? activeSchema : undefined,
system,
messages,
thinking:
model.provider === 'Anthropic' &&
model.kind === 'reasoner' &&
param.reasoningEffort['range'] > 0
? {
type: 'enabled',
budget_tokens:
param.reasoningEffort['range'] === 1000 ? 1024 : param.reasoningEffort['range'],
}
: undefined,
reasoning_effort:
model.provider === 'OpenAI' && model.reasoningEffortControls === 'low-medium-high'
? convo.reasoningEffort || 'high'
: undefined,
...(model.provider === 'OpenRouter' && model.kind === 'reasoner'
? model.reasoningEffortControls === 'low-medium-high'
? { reasoning: { effort: param.reasoningEffort['low-medium-high'] || 'high' } }
: model.reasoningEffortControls === 'range' && param.reasoningEffort['range'] > 0
? {
reasoning: {
max_tokens:
param.reasoningEffort['range'] === 1000
? 1024
: param.reasoningEffort['range'],
},
}
: {}
: {}),
include_reasoning:
model.provider === 'OpenRouter' && model.reasoningTracesVisibility !== 'hidden'
? true
: undefined,
provider:
model.provider === 'OpenRouter'
? {
sort: 'throughput',
}
: undefined,
plugins:
convo.websearch && model.provider === 'OpenRouter'
? [
{
id: 'web',
max_results: 20,
search_prompt: 'Consider the following web results when forming your response:',
},
]
: undefined,
}),
});
};
const response = await completions(get(controller).signal);
if (!response.ok) {
let body = null;
try { body = await response.json(); } catch {}
const msg = body?.error_description || body?.error?.message || body?.message || `API error ${response.status}`;
const err = new Error(msg);
err.status = response.status;
if (response.status === 402) {
err.code = 'payment_required';
err.reason = body?.reason;
err.upgradeUrl = body?.upgradeUrl;
} else if (response.status === 429) {
err.code = 'rate_limited';
err.retryAfter = body?.retry_after;
} else if (activeSchema.length > 0 && /no endpoints?\s+(?:found|available)\s+that support tool/i.test(msg)) {
err.code = 'tools_unsupported';
err.modelId = model.id;
err.toolNames = activeSchema.map((t) => t.function?.name || t.name).filter(Boolean);
}
throw err;
}
if (stream) {
streamResponse(model.provider, response.body, onupdate, onabort);
} else {
const responseBody = await response.json();
onupdate(responseBody);
}
} catch (err) {
if (err.name === 'AbortError') return;
// fetch rejects with a bare TypeError when the request never reached the
// server (offline, DNS, a blocked or refused connection). Its message is
// "Failed to fetch", which told the user nothing; tag it so the UI can
// answer with something they can act on.
if (err instanceof TypeError && !err.code) err.code = 'network';
onabort?.(err);
}
}
function toolSchemaToAnthropicFormat(schema) {
return {
name: schema.function.name,
description: schema.function.description,
input_schema: schema.function.parameters,
};
}
function messageToOpenAIFormat(msg) {
const msgConverted = {
role: msg.role,
};
if (msg.contentParts) {
msgConverted.content = [
{
type: 'text',
text: msg.content,
},
...msg.contentParts,
];
} else if (msg.role === 'tool') {
msgConverted.content =
typeof msg.content === 'object' ? JSON.stringify(msg.content) : msg.content;
} else {
msgConverted.content = msg.content;
}
// Additional data for tool calls
if (msg.toolcalls) {
msgConverted.tool_calls = msg.toolcalls.map((t) => {
return {
id: t.id,
type: 'function',
function: {
name: t.name,
arguments: serializeToolCallArguments(t.arguments),
},
};
});
}
// Additional data for tool responses
if (msg.toolcallId && msg.name) {
msgConverted.tool_call_id = msg.toolcallId;
msgConverted.name = msg.name;
}
return msgConverted;
}
function messageToAnthropicFormat(msg) {
const msgConverted = {
role: msg.role === 'tool' ? 'user' : msg.role,
};
if (msg.contentParts) {
msgConverted.content = [
{
type: 'text',
text: msg.content,
},
...msg.contentParts.map((part) => {
return {
type: 'image',
source: {
type: 'base64',
media_type: 'image/png',
data: part.image_url.url.slice('data:image/png;base64,'.length),
},
};
}),
];
} else if (msg.role === 'tool') {
let content;
if (typeof msg.content === 'object') {
if (msg.content.contentType === 'image/png') {
content = [
{
type: 'image',
source: {
type: 'base64',
media_type: 'image/png',
data: msg.content.content.slice('data:image/png;base64,'.length),
},
},
];
} else {
content = JSON.stringify(msg.content);
}
} else {
content = msg.content;
}
msgConverted.content = [
{
type: 'tool_result',
tool_use_id: msg.toolcallId,
content,
},
];
} else {
// Additional data for tool calls
if (msg.toolcalls) {
msgConverted.content = [];
if (msg.content !== '') {
msgConverted.content.push({ type: 'text', text: msg.content });
}
for (const t of msg.toolcalls) {
msgConverted.content.push({ type: 'tool_use', id: t.id, name: t.name, input: t.arguments });
}
} else {
msgConverted.content = msg.content;
}
}
return msgConverted;
}
async function streamResponse(provider, readableStream, onupdate, onabort) {
try {
const reader = readableStream.getReader();
const decoder = new TextDecoder();
let done, value;
let leftover = '';
while (!done) {
({ value, done } = await reader.read());
if (done) {
return;
}
const string = decoder.decode(value);
const pairs = string.split('\n\n');
for (let pair of pairs) {
if (pair === '') {
continue;
}
// If we have leftover from the previous chunk, prepend it to the current line
if (leftover !== '') {
pair = leftover + pair;
leftover = '';
}
// Ignore comments
if (pair[0] === ':') {
continue;
}
// OpenAI and only OpenAI sometimes sends "\ndata:"
pair = pair.trim();
let event = null;
let data = null;
if (pair.startsWith('event:')) {
const [eventd, datad] = pair.split('\n');
event = eventd.substring('event: '.length);
data = datad.substring('data: '.length);
} else if (pair.startsWith('data: ')) {
data = pair.substring('data: '.length);
} else if (pair.startsWith('error: ')) {
onupdate({ error: pair.substring('error: '.length) });
onabort();
return;
} else {
// Unknown event
onupdate({ error: pair });
onabort();
return;
}
if (provider === 'Anthropic') {
extractResponseAnthropic(event, data, onupdate);
} else {
// OpenAI-compatible:
extractResponseOpenAI(data, onupdate, () => {
leftover = pair;
});
}
}
}
} catch (error) {
if (error instanceof DOMException && error.name === 'AbortError') {
onabort();
} else {
// The stream died after the reply started. Say so, and say what is
// safe to do next, rather than printing the transport's own wording.
onupdate({
error:
error instanceof TypeError
? 'The reply stopped early because the connection dropped. Hover this reply and press the refresh button to regenerate it.'
: error.message,
});
}
}
}
function extractResponseOpenAI(data, onupdate, onincomplete) {
try {
const parsed = JSON.parse(data);
onupdate(parsed);
} catch (err) {
// If the JSON parsing fails, we've got an incomplete event
onincomplete();
}
}
function extractResponseAnthropic(event, data, onupdate) {
const datap = JSON.parse(data);
switch (event) {
case 'message_delta':
if (datap.delta.stop_reason) {
const openAIReasons = {
end_turn: 'end_turn',
tool_use: 'tool_calls',
};
onupdate({
choices: [{ delta: {}, finish_reason: openAIReasons[datap.delta.stop_reason] }],
});
}
break;
case 'content_block_start':
if (datap.content_block.type === 'tool_use') {
onupdate({
choices: [
{
delta: {
tool_calls: [
{
index: datap.index,
id: datap.content_block.id,
function: {
name: datap.content_block.name,
arguments: '',
},
},
],
},
},
],
});
}
break;
case 'content_block_delta':
if (datap.delta.type === 'text_delta') {
onupdate({
choices: [{ delta: { content: datap.delta.text } }],
});
} else if (datap.delta.type === 'input_json_delta') {
onupdate({
choices: [
{
delta: {
tool_calls: [
{
index: datap.index,
function: {
arguments: datap.delta.partial_json,
},
},
],
},
},
],
});
} else if (datap.delta.type === 'thinking_delta' && datap.delta.thinking) {
onupdate({
choices: [{ delta: { reasoning: datap.delta.thinking } }],
});
}
break;
}
}
function limitMessagesContext(messages, messagesContextLimit) {
if (messagesContextLimit <= 0) return messages;
const isFirstMessageSystem = messages[0]?.role === 'system';
const systemMessage = isFirstMessageSystem ? messages[0] : null;
const conversationMessages = isFirstMessageSystem ? messages.slice(1) : messages;
const turns = [];
let currentTurn = [];
for (const message of conversationMessages) {
if (message.role === 'user' && currentTurn.length > 0) {
turns.push(currentTurn);
currentTurn = [];
}
currentTurn.push(message);
}
if (currentTurn.length > 0) {
turns.push(currentTurn);
}
const limitedTurns = turns.slice(-messagesContextLimit);
const limitedMessages = limitedTurns.flat();
if (systemMessage) {
limitedMessages.unshift(systemMessage);
}
return limitedMessages;
}
export async function generateImage(convo, { oncomplete }) {
const model = convo.models[0];
const provider = providers.find((p) => p.name === model.provider);
const userMessages = convo.messages.filter((msg) => msg.role === 'user');
const lastMessage = userMessages[userMessages.length - 1];
const resp = await fetch(`${provider.url}/v1/images/generations`, {
method: 'POST',
headers: {
Authorization: `Bearer ${provider.apiKeyFn()}`,
'HTTP-Referer': 'https://three.ws',
'X-Title': 'three.ws chat',
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: model.id,
prompt: lastMessage.content,
n: 1,
size: '1024x1024',
}),
});
if (!resp.ok) {
let msg = `Image API error ${resp.status}`;
try { const e = await resp.json(); msg = e?.error?.message || e?.message || msg; } catch {}
throw new Error(msg);
}
const json = await resp.json();
oncomplete(json);
}