766 lines
25 KiB
Lua
766 lines
25 KiB
Lua
local PING_PROMPT = 'reply with exactly: pong';
|
|
|
|
local DEFAULT_TIMEOUT_SECONDS = 60;
|
|
local MAX_TIMEOUT_SECONDS = 60;
|
|
local DEFAULT_POLL_TIMEOUT_SECONDS = 600;
|
|
local MAX_POLL_TIMEOUT_SECONDS = 600;
|
|
local DEFAULT_POLL_INTERVAL_SECONDS = 2;
|
|
local DEFAULT_LUA_EXEC_MAX_RETRIES = 2;
|
|
local DEFAULT_LUA_EXEC_TIMEOUT_SECONDS = 5;
|
|
local DEFAULT_SESSION_SETTING_KEY = 'opencc.session_id';
|
|
local DEFAULT_AGENT_SETTING_KEY = 'opencc.agent';
|
|
|
|
local createHttp = require('/apis/libhttp');
|
|
|
|
local function isBlank(s)
|
|
return type(s) ~= 'string' or string.match(s, '^%s*$') ~= nil;
|
|
end
|
|
|
|
local function extractTextParts(parts)
|
|
if type(parts) ~= 'table' then
|
|
return '';
|
|
end
|
|
local texts = {};
|
|
for _, part in ipairs(parts) do
|
|
if type(part) == 'table' and part.type == 'text' and type(part.text) == 'string' then
|
|
texts[#texts + 1] = part.text;
|
|
end
|
|
end
|
|
return table.concat(texts, '');
|
|
end
|
|
|
|
local function nowSeconds()
|
|
if os.epoch then
|
|
return os.epoch('utc') / 1000;
|
|
end
|
|
return os.clock();
|
|
end
|
|
|
|
local function tablePack(...)
|
|
return { n = select('#', ...), ... };
|
|
end
|
|
|
|
local function endsWithNewline(s)
|
|
return type(s) == 'string' and string.sub(s, -1) == '\n';
|
|
end
|
|
|
|
local function valuesToLine(values, first, last)
|
|
local parts = {};
|
|
for i = first, last do
|
|
parts[#parts + 1] = tostring(values[i]);
|
|
end
|
|
return table.concat(parts, '\t');
|
|
end
|
|
|
|
local function classifyLuaRuntimeError(err)
|
|
local text = tostring(err or '');
|
|
if string.find(text, 'attempt to', 1, true) and string.find(text, 'nil value', 1, true) then
|
|
return 'identifier';
|
|
end
|
|
if string.find(text, 'global', 1, true) and string.find(text, 'nil', 1, true) then
|
|
return 'identifier';
|
|
end
|
|
return 'other';
|
|
end
|
|
|
|
local function renderOutput(output)
|
|
if output == nil or output == '' then
|
|
return '(no output)';
|
|
end
|
|
return output;
|
|
end
|
|
|
|
local function buildLuaExecPrompt(userPrompt)
|
|
return table.concat({
|
|
'Write ComputerCraft Lua code to answer this user request.',
|
|
'Reply with raw Lua code only. Do not use markdown fences or explanations.',
|
|
'The code runs locally with normal ComputerCraft globals available.',
|
|
'Use print() or write() for values that should be sent back. Returned values are captured too.',
|
|
'',
|
|
'User request:',
|
|
userPrompt,
|
|
}, '\n');
|
|
end
|
|
|
|
local function buildLuaCorrectionPrompt(userPrompt, code, err, errorKind)
|
|
return table.concat({
|
|
'The previous ComputerCraft Lua failed.',
|
|
'Reply with corrected raw Lua code only. Do not use markdown fences or explanations.',
|
|
'',
|
|
'Original user request:',
|
|
userPrompt,
|
|
'',
|
|
'Error kind: ' .. tostring(errorKind),
|
|
'Error:',
|
|
tostring(err),
|
|
'',
|
|
'Previous code:',
|
|
code,
|
|
}, '\n');
|
|
end
|
|
|
|
local function buildLuaOutputPrompt(userPrompt, output)
|
|
return table.concat({
|
|
'The Lua executed successfully.',
|
|
'Answer the original user request in natural language using the output below.',
|
|
'Do not write more Lua unless the user explicitly asked for code.',
|
|
'',
|
|
'Original user request:',
|
|
userPrompt,
|
|
'',
|
|
'Lua output:',
|
|
renderOutput(output),
|
|
}, '\n');
|
|
end
|
|
|
|
local function readOsValue(osLib, name)
|
|
if type(osLib) ~= 'table' or type(osLib[name]) ~= 'function' then
|
|
return nil;
|
|
end
|
|
local ok, value = pcall(osLib[name]);
|
|
if not ok then return nil; end
|
|
return value;
|
|
end
|
|
|
|
local function buildPromptWithCallerContext(prompt, osLib)
|
|
local lines = {
|
|
'<caller-context hidden="true">',
|
|
'Use this context silently to identify the in-game ComputerCraft caller.',
|
|
};
|
|
local computerId = readOsValue(osLib, 'getComputerID');
|
|
local computerLabel = readOsValue(osLib, 'getComputerLabel');
|
|
if computerId ~= nil then
|
|
lines[#lines + 1] = 'computer id: ' .. tostring(computerId);
|
|
end
|
|
if not isBlank(computerLabel) then
|
|
lines[#lines + 1] = 'computer label: ' .. tostring(computerLabel);
|
|
end
|
|
lines[#lines + 1] = '</caller-context>';
|
|
lines[#lines + 1] = '';
|
|
lines[#lines + 1] = 'User prompt:';
|
|
lines[#lines + 1] = prompt;
|
|
return table.concat(lines, '\n');
|
|
end
|
|
|
|
local function sessionTime(session)
|
|
if type(session) ~= 'table' or type(session.time) ~= 'table' then
|
|
return 0;
|
|
end
|
|
return tonumber(session.time.updated or session.time.created) or 0;
|
|
end
|
|
|
|
local function createAi(opts)
|
|
opts = opts or {};
|
|
|
|
local httpLib = opts.http or http;
|
|
local settingsLib = opts.settings or settings;
|
|
local eventloopFactory = opts.eventloop or require('/apis/eventloop');
|
|
local nowFunc = opts.now or nowSeconds;
|
|
local osLib = opts.os or os;
|
|
local httpClient = opts.httpClient or createHttp({ http = httpLib });
|
|
|
|
local api = {};
|
|
|
|
local function resolveTimeout(options)
|
|
local raw = options.timeoutSeconds;
|
|
if raw == nil then raw = settingsLib.get('opencc.timeout_seconds'); end
|
|
local n = tonumber(raw);
|
|
if not n or n <= 0 then n = DEFAULT_TIMEOUT_SECONDS; end
|
|
if n > MAX_TIMEOUT_SECONDS then n = MAX_TIMEOUT_SECONDS; end
|
|
return n;
|
|
end
|
|
|
|
local function resolvePollTimeout(options)
|
|
local raw = options.pollTimeoutSeconds;
|
|
if raw == nil then raw = settingsLib.get('opencc.poll_timeout_seconds'); end
|
|
local n = tonumber(raw);
|
|
if not n or n <= 0 then n = DEFAULT_POLL_TIMEOUT_SECONDS; end
|
|
if n > MAX_POLL_TIMEOUT_SECONDS then n = MAX_POLL_TIMEOUT_SECONDS; end
|
|
return n;
|
|
end
|
|
|
|
local function resolvePollInterval(options)
|
|
local raw = options.pollIntervalSeconds;
|
|
if raw == nil then raw = settingsLib.get('opencc.poll_interval_seconds'); end
|
|
local n = tonumber(raw);
|
|
if not n or n <= 0 then n = DEFAULT_POLL_INTERVAL_SECONDS; end
|
|
return n;
|
|
end
|
|
|
|
local function resolveLuaExecMaxRetries(options)
|
|
local n = tonumber(options.maxRetries);
|
|
if n and n >= 0 then return math.floor(n); end
|
|
return DEFAULT_LUA_EXEC_MAX_RETRIES;
|
|
end
|
|
|
|
local function resolveLuaExecTimeout(options)
|
|
if options.luaTimeoutSeconds == false then return nil; end
|
|
local n = tonumber(options.luaTimeoutSeconds);
|
|
if n and n > 0 then return n; end
|
|
return DEFAULT_LUA_EXEC_TIMEOUT_SECONDS;
|
|
end
|
|
|
|
local function resolveModel(options)
|
|
local providerId = options.providerID or settingsLib.get('opencc.provider_id');
|
|
local modelId = options.modelID or settingsLib.get('opencc.model_id');
|
|
if isBlank(providerId) or isBlank(modelId) then
|
|
return nil, nil;
|
|
end
|
|
return providerId, modelId;
|
|
end
|
|
|
|
local function resolveAgent(options)
|
|
local agent = options.agent;
|
|
if agent == nil then agent = settingsLib.get(DEFAULT_AGENT_SETTING_KEY); end
|
|
if isBlank(agent) then return nil; end
|
|
return agent;
|
|
end
|
|
|
|
local function resolveConfig(options)
|
|
local url = options.serverUrl or settingsLib.get('opencc.server_url');
|
|
if not url or url == '' then
|
|
return nil, 'missing opencc.server_url; run: set opencc.server_url <url>';
|
|
end
|
|
local username = options.username or settingsLib.get('opencc.username') or 'opencode';
|
|
local password = options.password or settingsLib.get('opencc.password') or '';
|
|
local directory = options.directory or settingsLib.get('opencc.directory');
|
|
local providerId, modelId = resolveModel(options);
|
|
return {
|
|
url = httpClient.trimTrailingSlash(url),
|
|
username = username,
|
|
password = password,
|
|
directory = directory,
|
|
providerID = providerId,
|
|
modelID = modelId,
|
|
agent = resolveAgent(options),
|
|
timeoutSeconds = resolveTimeout(options),
|
|
pollTimeoutSeconds = resolvePollTimeout(options),
|
|
pollIntervalSeconds = resolvePollInterval(options),
|
|
};
|
|
end
|
|
|
|
local function buildPromptBody(cfg, messageId, prompt)
|
|
local body = {
|
|
messageID = messageId,
|
|
parts = { { type = 'text', text = prompt } },
|
|
};
|
|
if cfg.providerID and cfg.modelID then
|
|
body.model = { providerID = cfg.providerID, modelID = cfg.modelID };
|
|
end
|
|
if cfg.agent then
|
|
body.agent = cfg.agent;
|
|
end
|
|
return body;
|
|
end
|
|
|
|
local function buildMessageBody(cfg, prompt)
|
|
local body = {
|
|
parts = { { type = 'text', text = prompt } },
|
|
};
|
|
if cfg.providerID and cfg.modelID then
|
|
body.model = { providerID = cfg.providerID, modelID = cfg.modelID };
|
|
end
|
|
if cfg.agent then
|
|
body.agent = cfg.agent;
|
|
end
|
|
return body;
|
|
end
|
|
|
|
local function createMessageId()
|
|
local t = math.floor(nowFunc() * 1000);
|
|
return 'msg_' .. tostring(t) .. '_' .. tostring(math.random(100000, 999999));
|
|
end
|
|
|
|
local function isMessageComplete(message)
|
|
if type(message) ~= 'table' or type(message.info) ~= 'table' then
|
|
return false;
|
|
end
|
|
if type(message.info.finish) == 'string' then
|
|
return true;
|
|
end
|
|
return type(message.info.time) == 'table' and message.info.time.completed ~= nil;
|
|
end
|
|
|
|
local function errorMessage(errorInfo)
|
|
if type(errorInfo) ~= 'table' then return nil; end
|
|
if type(errorInfo.data) == 'table' and type(errorInfo.data.message) == 'string' then
|
|
return errorInfo.data.message;
|
|
end
|
|
if type(errorInfo.message) == 'string' then
|
|
return errorInfo.message;
|
|
end
|
|
if type(errorInfo.name) == 'string' then
|
|
return errorInfo.name;
|
|
end
|
|
return 'unknown assistant error';
|
|
end
|
|
|
|
local function sessionStatusText(status)
|
|
if type(status) ~= 'table' then return nil; end
|
|
if type(status.type) ~= 'string' then return nil; end
|
|
if status.type == 'retry' then
|
|
return 'retry #' .. tostring(status.attempt or '?') .. ': ' .. tostring(status.message or 'unknown error');
|
|
end
|
|
return status.type;
|
|
end
|
|
|
|
local function decodeMessage(value)
|
|
local decoded = value;
|
|
if type(value) == 'string' then
|
|
decoded = textutils.unserializeJSON(value);
|
|
end
|
|
if type(decoded) ~= 'table' or type(decoded.parts) ~= 'table' then
|
|
return nil, 'reponse message invalide';
|
|
end
|
|
return decoded, nil;
|
|
end
|
|
|
|
local function findAssistantMessage(messages, submittedMessageId)
|
|
local seenSubmitted = false;
|
|
for _, message in ipairs(messages) do
|
|
if type(message) == 'table' and type(message.info) == 'table' then
|
|
if message.info.id == submittedMessageId and message.info.role == 'assistant' then
|
|
return message;
|
|
elseif message.info.id == submittedMessageId then
|
|
seenSubmitted = true;
|
|
elseif seenSubmitted and message.info.role == 'assistant' then
|
|
return message;
|
|
end
|
|
end
|
|
end
|
|
return nil;
|
|
end
|
|
|
|
local function handleMissingSession(persist, sessionSettingKey)
|
|
if persist then
|
|
settingsLib.unset(sessionSettingKey or DEFAULT_SESSION_SETTING_KEY);
|
|
if settingsLib.save then settingsLib.save(); end
|
|
end
|
|
return false, 'session introuvable; lance: ai new <prompt>';
|
|
end
|
|
|
|
local doGet;
|
|
local doPost;
|
|
|
|
local function pollMessage(cfg, sessionId, messageId, persist, sessionSettingKey, log)
|
|
local loop = eventloopFactory();
|
|
local deadline = nowFunc() + cfg.pollTimeoutSeconds;
|
|
local resultOk, resultValue;
|
|
local attemptCount = 0;
|
|
log = log or function() end;
|
|
|
|
local function finish(ok, value)
|
|
resultOk, resultValue = ok, value;
|
|
loop.stopLoop();
|
|
end
|
|
|
|
local function attempt()
|
|
attemptCount = attemptCount + 1;
|
|
local body, code = doGet(cfg, '/session/' .. sessionId .. '/message');
|
|
if not body then
|
|
log('poll #' .. tostring(attemptCount) .. ': transient error: ' .. tostring(code));
|
|
if nowFunc() >= deadline then
|
|
return finish(false, code);
|
|
end
|
|
return loop.setTimeout(attempt, cfg.pollIntervalSeconds);
|
|
end
|
|
if code == 404 then
|
|
local ok, value = handleMissingSession(persist, sessionSettingKey);
|
|
return finish(ok, value);
|
|
end
|
|
if code and code ~= 200 then
|
|
return finish(false, 'erreur message: HTTP ' .. tostring(code));
|
|
end
|
|
|
|
local messages = textutils.unserializeJSON(body);
|
|
if type(messages) ~= 'table' then
|
|
return finish(false, 'reponse message invalide');
|
|
end
|
|
local decoded = findAssistantMessage(messages, messageId);
|
|
local reply = decoded and extractTextParts(decoded.parts) or '';
|
|
local complete = decoded and isMessageComplete(decoded) or false;
|
|
local matchedId = decoded and type(decoded.info) == 'table' and decoded.info.id or 'nil';
|
|
local assistantError = decoded and type(decoded.info) == 'table' and errorMessage(decoded.info.error) or nil;
|
|
log('poll #' .. tostring(attemptCount)
|
|
.. ': messages=' .. tostring(#messages)
|
|
.. ', found=' .. tostring(matchedId)
|
|
.. ', complete=' .. tostring(complete)
|
|
.. ', text=' .. tostring(reply ~= '')
|
|
.. ', error=' .. tostring(assistantError ~= nil));
|
|
if assistantError then
|
|
return finish(false, 'erreur assistant: ' .. assistantError);
|
|
end
|
|
if decoded and reply ~= '' and complete then
|
|
log('async reply completed');
|
|
return finish(true, { reply = reply, sessionId = sessionId, messageId = messageId });
|
|
end
|
|
if nowFunc() >= deadline then
|
|
local statusBody, statusCodeValue = doGet(cfg, '/session/status');
|
|
if statusBody and (not statusCodeValue or statusCodeValue == 200) then
|
|
local statuses = textutils.unserializeJSON(statusBody);
|
|
local statusText = type(statuses) == 'table' and sessionStatusText(statuses[sessionId]) or nil;
|
|
if statusText then
|
|
log('session status at timeout: ' .. statusText);
|
|
return finish(false, 'delai depasse en attendant la reponse AI (status: ' .. statusText .. ')');
|
|
end
|
|
end
|
|
return finish(false, 'delai depasse en attendant la reponse AI');
|
|
end
|
|
loop.setTimeout(attempt, cfg.pollIntervalSeconds);
|
|
end
|
|
|
|
loop.setTimeout(attempt, 0);
|
|
loop.runLoop();
|
|
return resultOk, resultValue;
|
|
end
|
|
|
|
function doGet(cfg, path)
|
|
return httpClient.getJson(cfg, path);
|
|
end
|
|
|
|
function doPost(cfg, path, payload)
|
|
return httpClient.postJson(cfg, path, payload);
|
|
end
|
|
|
|
local function askBlocking(cfg, sessionId, prompt, persist, sessionSettingKey, log)
|
|
log('sending blocking message');
|
|
local body, code = doPost(cfg, '/session/' .. sessionId .. '/message', buildMessageBody(cfg, prompt));
|
|
if not body then return false, code; end
|
|
if code == 404 then
|
|
return handleMissingSession(persist, sessionSettingKey);
|
|
end
|
|
if code and code ~= 200 then
|
|
return false, 'erreur message: HTTP ' .. tostring(code);
|
|
end
|
|
|
|
local decoded, decodeErr = decodeMessage(body);
|
|
if not decoded then return false, decodeErr; end
|
|
local reply = extractTextParts(decoded.parts);
|
|
if reply == '' then return false, 'reponse vide'; end
|
|
return true, {
|
|
reply = reply,
|
|
sessionId = sessionId,
|
|
messageId = type(decoded.info) == 'table' and decoded.info.id or nil,
|
|
};
|
|
end
|
|
|
|
local function listSessionsWithDirectory(cfg, directory)
|
|
return doGet(cfg, '/session' .. httpClient.queryString({ { 'directory', directory } }));
|
|
end
|
|
|
|
local function decodeSessionList(body, log)
|
|
local decoded = textutils.unserializeJSON(body);
|
|
if type(decoded) ~= 'table' then
|
|
log('list sessions failed: invalid response');
|
|
return nil, 'reponse invalide';
|
|
end
|
|
table.sort(decoded, function(a, b)
|
|
return sessionTime(a) > sessionTime(b);
|
|
end);
|
|
return decoded, nil;
|
|
end
|
|
|
|
function api.clearSession(options)
|
|
options = options or {};
|
|
settingsLib.unset(options.sessionSettingKey or DEFAULT_SESSION_SETTING_KEY);
|
|
if settingsLib.save then settingsLib.save(); end
|
|
end
|
|
|
|
function api.listSessions(options)
|
|
options = options or {};
|
|
local log = options.log or function() end;
|
|
local cfg, err = resolveConfig(options);
|
|
if not cfg then return false, err; end
|
|
|
|
local directory = cfg.directory;
|
|
local sessionSettingKey = options.sessionSettingKey or DEFAULT_SESSION_SETTING_KEY;
|
|
log('listing sessions from ' .. cfg.url);
|
|
local body, code;
|
|
if isBlank(directory) then
|
|
body, code = doGet(cfg, '/session');
|
|
else
|
|
log('listing sessions for directory ' .. tostring(directory));
|
|
body, code = listSessionsWithDirectory(cfg, directory);
|
|
end
|
|
if not body then
|
|
log('list sessions failed: ' .. tostring(code));
|
|
return false, code;
|
|
end
|
|
if code and code ~= 200 then
|
|
log('list sessions failed: HTTP ' .. tostring(code));
|
|
return false, 'erreur serveur: HTTP ' .. tostring(code);
|
|
end
|
|
|
|
local decoded, decodeErr = decodeSessionList(body, log);
|
|
if not decoded then return false, decodeErr; end
|
|
|
|
if #decoded == 0 and isBlank(directory) then
|
|
local sessionId = options.sessionId or settingsLib.get(sessionSettingKey);
|
|
if not isBlank(sessionId) then
|
|
log('session list empty; resolving directory from ' .. tostring(sessionId));
|
|
local sessionBody, sessionCode = doGet(cfg, '/session/' .. sessionId);
|
|
if sessionBody and (not sessionCode or sessionCode == 200) then
|
|
local session = textutils.unserializeJSON(sessionBody);
|
|
if type(session) == 'table' and not isBlank(session.directory) then
|
|
log('retrying sessions for directory ' .. tostring(session.directory));
|
|
local scopedBody, scopedCode = listSessionsWithDirectory(cfg, session.directory);
|
|
if scopedBody and (not scopedCode or scopedCode == 200) then
|
|
local scoped, scopedErr = decodeSessionList(scopedBody, log);
|
|
if not scoped then return false, scopedErr; end
|
|
decoded = scoped;
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
log('sessions returned: ' .. tostring(#decoded));
|
|
return true, decoded;
|
|
end
|
|
|
|
function api.ask(prompt, options)
|
|
options = options or {};
|
|
local log = options.log or function() end;
|
|
if isBlank(prompt) then
|
|
return false, 'missing prompt; usage: ai <prompt>';
|
|
end
|
|
|
|
local cfg, err = resolveConfig(options);
|
|
if not cfg then return false, err; end
|
|
|
|
local persist = options.persist ~= false;
|
|
local sessionSettingKey = options.sessionSettingKey or DEFAULT_SESSION_SETTING_KEY;
|
|
local sessionId = options.sessionId;
|
|
if persist and sessionId == nil then
|
|
sessionId = settingsLib.get(sessionSettingKey);
|
|
end
|
|
|
|
if not sessionId or sessionId == '' then
|
|
log('creating session');
|
|
local body, code = doPost(cfg, '/session', { title = options.sessionTitle or 'cc-ai' });
|
|
if not body then return false, code; end
|
|
if code and code ~= 200 then
|
|
return false, 'impossible de creer une session: HTTP ' .. tostring(code);
|
|
end
|
|
local decoded = textutils.unserializeJSON(body);
|
|
if type(decoded) ~= 'table' or type(decoded.id) ~= 'string' then
|
|
return false, 'reponse session invalide';
|
|
end
|
|
sessionId = decoded.id;
|
|
if persist then
|
|
settingsLib.set(sessionSettingKey, sessionId);
|
|
if settingsLib.save then settingsLib.save(); end
|
|
end
|
|
else
|
|
log('reusing session ' .. sessionId);
|
|
end
|
|
|
|
local promptWithContext = prompt;
|
|
if options.includeCallerContext ~= false then
|
|
promptWithContext = buildPromptWithCallerContext(prompt, osLib);
|
|
end
|
|
|
|
if options.blocking == true then
|
|
log('using blocking message endpoint');
|
|
return askBlocking(cfg, sessionId, promptWithContext, persist, sessionSettingKey, log);
|
|
end
|
|
|
|
local messageId = options.messageId or createMessageId();
|
|
log('sending async prompt ' .. messageId);
|
|
local body, code = doPost(cfg, '/session/' .. sessionId .. '/prompt_async',
|
|
buildPromptBody(cfg, messageId, promptWithContext));
|
|
if not body then return false, code; end
|
|
if code == 404 then
|
|
return handleMissingSession(persist, sessionSettingKey);
|
|
end
|
|
if code and code ~= 204 and code ~= 200 then
|
|
return false, 'erreur message: HTTP ' .. tostring(code);
|
|
end
|
|
|
|
if code == 200 and body and body ~= '' then
|
|
local decoded, decodeErr = decodeMessage(body);
|
|
if not decoded then return false, decodeErr; end
|
|
local reply = extractTextParts(decoded.parts);
|
|
if reply == '' then return false, 'reponse vide'; end
|
|
return true, { reply = reply, sessionId = sessionId, messageId = messageId };
|
|
end
|
|
|
|
return pollMessage(cfg, sessionId, messageId, persist, sessionSettingKey, log);
|
|
end
|
|
|
|
function api.createLuaExecutor(options)
|
|
options = options or {};
|
|
local baseEnv = options.env or _G;
|
|
local live = options.live ~= false;
|
|
local livePrint = options.print or print;
|
|
local liveWrite = options.write or write;
|
|
local timeoutSeconds = resolveLuaExecTimeout(options);
|
|
|
|
return function(code)
|
|
local buffer = {};
|
|
|
|
local function append(text)
|
|
buffer[#buffer + 1] = text;
|
|
end
|
|
|
|
local function capturedPrint(...)
|
|
local values = tablePack(...);
|
|
local line = valuesToLine(values, 1, values.n);
|
|
append(line .. '\n');
|
|
if live then livePrint(...); end
|
|
end
|
|
|
|
local function capturedWrite(text)
|
|
text = tostring(text or '');
|
|
append(text);
|
|
if live then liveWrite(text); end
|
|
end
|
|
|
|
local env = setmetatable({
|
|
print = capturedPrint,
|
|
write = capturedWrite,
|
|
}, { __index = baseEnv });
|
|
local chunk, loadErr = load(code, 'ai-lua-exec', 't', env);
|
|
if not chunk then
|
|
return false, tostring(loadErr), 'syntax';
|
|
end
|
|
|
|
local result;
|
|
local finished = false;
|
|
local function runner()
|
|
result = tablePack(pcall(chunk));
|
|
finished = true;
|
|
end
|
|
|
|
if timeoutSeconds then
|
|
parallel.waitForAny(runner, function() sleep(timeoutSeconds); end);
|
|
else
|
|
runner();
|
|
end
|
|
|
|
if not finished then
|
|
return false, 'lua execution timed out after ' .. tostring(timeoutSeconds) .. 's', 'other';
|
|
end
|
|
if not result[1] then
|
|
return false, tostring(result[2]), classifyLuaRuntimeError(result[2]);
|
|
end
|
|
if result.n > 1 then
|
|
if #buffer > 0 and not endsWithNewline(buffer[#buffer]) then
|
|
append('\n');
|
|
end
|
|
append(valuesToLine(result, 2, result.n) .. '\n');
|
|
end
|
|
return true, table.concat(buffer), nil;
|
|
end;
|
|
end
|
|
|
|
function api.luaExec(userPrompt, options)
|
|
options = options or {};
|
|
if isBlank(userPrompt) then
|
|
return false, { error = 'missing prompt; usage: ai lua-exec <prompt>', attempts = 0 };
|
|
end
|
|
|
|
local log = options.log or function() end;
|
|
local executor = options.executor or api.createLuaExecutor(options);
|
|
local maxRetries = resolveLuaExecMaxRetries(options);
|
|
local maxAttempts = maxRetries + 1;
|
|
local sessionId;
|
|
|
|
local function askOptions()
|
|
return {
|
|
persist = false,
|
|
sessionId = sessionId,
|
|
sessionTitle = 'cc-ai lua-exec',
|
|
serverUrl = options.serverUrl,
|
|
username = options.username,
|
|
password = options.password,
|
|
providerID = options.providerID,
|
|
modelID = options.modelID,
|
|
agent = options.agent,
|
|
timeoutSeconds = options.timeoutSeconds,
|
|
};
|
|
end
|
|
|
|
log('requesting Lua from AI');
|
|
local ok, result = api.ask(buildLuaExecPrompt(userPrompt), askOptions());
|
|
if not ok then
|
|
return false, { error = result, attempts = 0, errorKind = 'ai' };
|
|
end
|
|
sessionId = result.sessionId;
|
|
log('session: ' .. sessionId);
|
|
|
|
local code = result.reply;
|
|
for attempt = 1, maxAttempts do
|
|
log('attempt ' .. tostring(attempt) .. '/' .. tostring(maxAttempts));
|
|
log('code:\n' .. code);
|
|
|
|
local execOk, outputOrErr, errorKind = executor(code);
|
|
if execOk then
|
|
local output = outputOrErr or '';
|
|
log('output:\n' .. renderOutput(output));
|
|
log('requesting final reply');
|
|
local finalOk, finalResult = api.ask(buildLuaOutputPrompt(userPrompt, output), askOptions());
|
|
if not finalOk then
|
|
return false, {
|
|
error = finalResult,
|
|
attempts = attempt,
|
|
errorKind = 'ai',
|
|
code = code,
|
|
output = output,
|
|
sessionId = sessionId,
|
|
};
|
|
end
|
|
log('final reply received');
|
|
return true, {
|
|
reply = finalResult.reply,
|
|
output = output,
|
|
code = code,
|
|
attempts = attempt,
|
|
sessionId = sessionId,
|
|
};
|
|
end
|
|
|
|
errorKind = errorKind or 'other';
|
|
log('error (' .. tostring(errorKind) .. '):\n' .. tostring(outputOrErr));
|
|
if (errorKind ~= 'syntax' and errorKind ~= 'identifier') or attempt >= maxAttempts then
|
|
return false, {
|
|
error = outputOrErr,
|
|
attempts = attempt,
|
|
errorKind = errorKind,
|
|
code = code,
|
|
sessionId = sessionId,
|
|
retryExhausted = attempt >= maxAttempts,
|
|
};
|
|
end
|
|
|
|
log('requesting corrected Lua');
|
|
local correctionOk, correctionResult = api.ask(
|
|
buildLuaCorrectionPrompt(userPrompt, code, outputOrErr, errorKind),
|
|
askOptions()
|
|
);
|
|
if not correctionOk then
|
|
return false, {
|
|
error = correctionResult,
|
|
attempts = attempt,
|
|
errorKind = 'ai',
|
|
code = code,
|
|
sessionId = sessionId,
|
|
};
|
|
end
|
|
code = correctionResult.reply;
|
|
end
|
|
|
|
return false, { error = 'lua-exec failed unexpectedly', attempts = maxAttempts };
|
|
end
|
|
|
|
function api.ping(options)
|
|
options = options or {};
|
|
options.includeCallerContext = false;
|
|
return api.ask(PING_PROMPT, options);
|
|
end
|
|
|
|
return api;
|
|
end
|
|
|
|
return createAi;
|