ticlawk 0.1.16-dev.8 → 0.1.16

package/src/adapters/ticlawk/api.mjs

@@ -30,8 +30,9 @@ export function getConnectorWsUrl() {
   return DEFAULT_CONNECTOR_WS_URL;
 }
 
-// Agent event writes must preserve per-agent order while still allowing
-// different agents to proceed concurrently.
+// Non-terminal event writes are serialized per agent for stable logs.
+// Terminal turn events bypass this queue so telemetry cannot hold up the
+// delivery lifecycle.
 const agentEventQueues = new Map(); // agentId -> Promise
 
 export class TiclawkUpdateRequiredError extends Error {
@@ -188,6 +189,7 @@ export async function sendAgentMessage({
   runtimeHostId,
   visibility,
   mediaAssetIds,
+  metadata,
 }) {
   const { data } = await apiFetch('/api/agent/messages/send', {
     method: 'POST',
@@ -200,6 +202,7 @@ export async function sendAgentMessage({
       runtime_host_id: runtimeHostId ?? null,
       visibility: visibility || null,
       media_asset_ids: Array.isArray(mediaAssetIds) && mediaAssetIds.length > 0 ? mediaAssetIds : undefined,
+      metadata: metadata ?? undefined,
     }),
   });
   return data || null;
@@ -222,7 +225,7 @@ export async function readAgentMessages({
   return data || [];
 }
 
-export async function createAgentTask({ actingAgentId, conversationId, text, title }) {
+export async function createAgentTask({ actingAgentId, conversationId, text, title, assignAgentId }) {
   return apiFetch('/api/agent/tasks/create', {
     method: 'POST',
     body: JSON.stringify({
@@ -230,6 +233,7 @@ export async function createAgentTask({ actingAgentId, conversationId, text, tit
       conversation_id: conversationId,
       text,
       title: title ?? null,
+      assign_agent_id: assignAgentId ?? null,
     }),
   });
 }
@@ -484,63 +488,294 @@ export async function removeAgentGroupMember({
   );
 }
 
+// ── Workstreams (managed groups) ──
+
+export async function createWorkstream({
+  actingAgentId, name, description, charter, memberAgentIds,
+}) {
+  return apiFetch('/api/agent/workstreams', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      description: description ?? null,
+      charter: charter ?? null,
+      member_agent_ids: memberAgentIds || [],
+    }),
+  });
+}
+
+export async function deleteWorkstream({ actingAgentId, conversationId }) {
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}`,
+    {
+      method: 'DELETE',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
+    },
+  );
+}
+
+export async function listWorkstreams({ actingAgentId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  const { data } = await apiFetch(`/api/agent/workstreams?${params}`);
+  return data || [];
+}
+
+// ── Agents ──
+
+export async function listAgentSlots({ actingAgentId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  const { data } = await apiFetch(`/api/agent/agents?${params}`);
+  return data || [];
+}
+
+export async function createAgentSlot({
+  actingAgentId, name, runtime, description, displayName, model,
+}) {
+  return apiFetch('/api/agent/agents', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      runtime,
+      description: description ?? null,
+      display_name: displayName ?? null,
+      model: model ?? null,
+    }),
+  });
+}
+
+export async function archiveAgentSlot({ actingAgentId, agentId }) {
+  return apiFetch(
+    `/api/agent/agents/${encodeURIComponent(agentId)}`,
+    {
+      method: 'DELETE',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
+    },
+  );
+}
+
+// ── Services ──
+
+export async function createService({
+  actingAgentId, name, description, contractSchema, endpointConfig,
+}) {
+  return apiFetch('/api/agent/services', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      description: description ?? null,
+      contract_schema: contractSchema ?? null,
+      endpoint_config: endpointConfig,
+    }),
+  });
+}
+
+export async function updateService({ actingAgentId, serviceId, ...patch }) {
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(serviceId)}`,
+    {
+      method: 'PATCH',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId, ...patch }),
+    },
+  );
+}
+
+export async function deleteService({ actingAgentId, serviceId }) {
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(serviceId)}`,
+    {
+      method: 'DELETE',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId }),
+    },
+  );
+}
+
+export async function listServices({ actingAgentId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  const { data } = await apiFetch(`/api/agent/services?${params}`);
+  return data || [];
+}
+
+export async function getServiceInfo({ actingAgentId, name }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(name)}/info?${params}`,
+  );
+}
+
+export async function callService({ actingAgentId, name, input }) {
+  return apiFetch(
+    `/api/agent/services/${encodeURIComponent(name)}/call`,
+    {
+      method: 'POST',
+      body: JSON.stringify({ acting_as_agent_id: actingAgentId, input }),
+    },
+  );
+}
+
+// ── Briefings ──
+
+export async function getBriefing({actingAgentId, briefingId}) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(`/api/agent/briefings/${encodeURIComponent(briefingId)}?${params}`);
+}
+
+export async function publishBriefing({actingAgentId, bodyText, attachmentAssetId, currentConversationId, responseMode}) {
+  const body = { acting_as_agent_id: actingAgentId };
+  if (bodyText != null) body.body_text = bodyText;
+  if (attachmentAssetId != null) body.attachment_asset_id = attachmentAssetId;
+  if (currentConversationId != null) body.current_conversation_id = currentConversationId;
+  if (responseMode != null) body.response_mode = responseMode;
+  return apiFetch('/api/agent/briefings', {
+    method: 'POST',
+    body: JSON.stringify(body),
+  });
+}
+
+// ── Credentials (slot creation + daemon sync) ──
+
+export async function fetchCredentials() {
+  return apiFetch('/api/agent/credentials', { method: 'GET' });
+}
+
+export async function requestCredential({
+  actingAgentId, name, description, workstreamId,
+}) {
+  return apiFetch('/api/agent/credentials', {
+    method: 'POST',
+    body: JSON.stringify({
+      acting_as_agent_id: actingAgentId,
+      name,
+      description: description ?? null,
+      workstream_id: workstreamId ?? null,
+    }),
+  });
+}
+
+// ── Workstream dashboard ──
+
+export async function setWorkstreamDashboard({
+  actingAgentId, conversationId, dataJson, htmlTemplate,
+}) {
+  const body = { acting_as_agent_id: actingAgentId };
+  // Distinguish "omit" from "set to null" — only include keys the caller
+  // explicitly passed (including null clears the field).
+  if (dataJson !== undefined) body.data_json = dataJson;
+  if (htmlTemplate !== undefined) body.html_template = htmlTemplate;
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/dashboard`,
+    { method: 'POST', body: JSON.stringify(body) },
+  );
+}
+
+export async function getWorkstreamDashboard({ actingAgentId, conversationId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/dashboard?${params}`,
+  );
+}
+
+// ── Workstream charter ──
+
+export async function getWorkstreamCharter({ actingAgentId, conversationId }) {
+  const params = new URLSearchParams();
+  params.set('acting_as_agent_id', actingAgentId);
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/charter?${params}`,
+  );
+}
+
+export async function setWorkstreamCharter({ actingAgentId, conversationId, charter }) {
+  return apiFetch(
+    `/api/agent/workstreams/${encodeURIComponent(conversationId)}/charter`,
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        acting_as_agent_id: actingAgentId,
+        charter: charter ?? null,
+      }),
+    },
+  );
+}
+
 // ── Channel event pipe ──
 
 export async function postEvent({ agent, agent_id, runtime_host_id, session_id, cwd, runtime_version, event, required = false }) {
   const agentId = agent_id || null;
   const queueKey = agentId || `${agent}:${session_id || ''}`;
-  const previous = agentEventQueues.get(queueKey) || Promise.resolve(null);
   const eventName = event?.worker_event_name || event?.hook_event_name || event?.event_name || 'unknown';
   const turnId = event?.turn_id || event?.reply_to_message_id || null;
   const seq = event?.event_seq ?? null;
   const deltaChars = typeof event?.delta === 'string' ? event.delta.length : null;
 
+  if (eventName === 'worker.message.delta') {
+    debugLog('events', 'delta.drop', {
+      agent,
+      agentId,
+      sessionId: shortId(session_id),
+      turnId: shortId(turnId),
+      deltaChars,
+    });
+    return null;
+  }
+
+  const postOnce = async () => {
+    const startedAt = Date.now();
+    try {
+      const result = await apiFetch('/api/events', {
+        method: 'POST',
+        body: JSON.stringify({ agent, agent_id: agentId, runtime_host_id, session_id, cwd, runtime_version, event }),
+        timeout: 5000,
+      });
+      if (required && result?.matched === false) {
+        throw new Error(`event was not matched (${eventName})`);
+      }
+      debugLog('events', 'post.ok', {
+        agent,
+        agentId,
+        sessionId: shortId(session_id),
+        runtimeVersion: runtime_version ?? null,
+        turnId: shortId(turnId),
+        eventName,
+        seq,
+        durationMs: Date.now() - startedAt,
+      });
+      return result;
+    } catch (err) {
+      debugError('events', 'post.failed', {
+        agent,
+        agentId,
+        sessionId: shortId(session_id),
+        runtimeVersion: runtime_version ?? null,
+        turnId: shortId(turnId),
+        eventName,
+        seq,
+        durationMs: Date.now() - startedAt,
+        error: err?.message || 'unknown error',
+      });
+      if (required) {
+        throw err;
+      }
+      return null;
+    }
+  };
+
+  if (eventName === 'worker.turn.complete' || eventName === 'worker.turn.error') {
+    return postOnce();
+  }
+
+  const previous = agentEventQueues.get(queueKey) || Promise.resolve(null);
   const queued = previous
     .catch(() => null)
-    .then(async () => {
-      const startedAt = Date.now();
-      try {
-        const result = await apiFetch('/api/events', {
-          method: 'POST',
-          body: JSON.stringify({ agent, agent_id: agentId, runtime_host_id, session_id, cwd, runtime_version, event }),
-          timeout: 5000,
-        });
-        if (required && result?.matched === false) {
-          throw new Error(`event was not matched (${eventName})`);
-        }
-        debugLog('events', 'post.ok', {
-          agent,
-          agentId,
-          sessionId: shortId(session_id),
-          runtimeVersion: runtime_version ?? null,
-          turnId: shortId(turnId),
-          eventName,
-          seq,
-          deltaChars,
-          durationMs: Date.now() - startedAt,
-        });
-        return result;
-      } catch (err) {
-        debugError('events', 'post.failed', {
-          agent,
-          agentId,
-          sessionId: shortId(session_id),
-          runtimeVersion: runtime_version ?? null,
-          turnId: shortId(turnId),
-          eventName,
-          seq,
-          deltaChars,
-          durationMs: Date.now() - startedAt,
-          error: err?.message || 'unknown error',
-        });
-        if (required) {
-          throw err;
-        }
-        // Best-effort by default. Callers that need a hard failure set
-        // `required: true` (used for the final reply path).
-        return null;
-      }
-    });
+    .then(postOnce);
 
   agentEventQueues.set(queueKey, queued);
   queued.finally(() => {

package/src/adapters/ticlawk/credentials.mjs

@@ -6,7 +6,20 @@
  * using the connector-specific env name.
  */
 
-import { AF_CONFIG_PATH, persistConfig, TICLAWK_CONNECTOR_API_KEY } from '../../core/config.mjs';
+import { AF_CONFIG_PATH, loadPersistentConfig, persistConfig, TICLAWK_CONNECTOR_API_KEY } from '../../core/config.mjs';
+
+export const TICLAWK_CREDENTIAL_NAMES = 'TICLAWK_CREDENTIAL_NAMES';
+
+function isRuntimeCredentialName(value) {
+  return /^[A-Z][A-Z0-9_]*$/.test(String(value || '').trim());
+}
+
+function parseCredentialNames(value) {
+  return String(value || '')
+    .split(',')
+    .map((name) => name.trim())
+    .filter(isRuntimeCredentialName);
+}
 
 export function persistApiCredential(apiKey) {
   if (!apiKey || !apiKey.startsWith('tk_')) return;
@@ -19,3 +32,30 @@ export function persistApiCredential(apiKey) {
   delete process.env.TICLAWK_SETUP_CODE;
   console.log(`[connect] saved ${TICLAWK_CONNECTOR_API_KEY} to ${AF_CONFIG_PATH}`);
 }
+
+export function persistRuntimeCredentials(credentials = []) {
+  const current = loadPersistentConfig();
+  const previousNames = new Set(parseCredentialNames(current[TICLAWK_CREDENTIAL_NAMES]));
+  const nextNames = [];
+  const updates = {};
+
+  for (const credential of Array.isArray(credentials) ? credentials : []) {
+    const name = String(credential?.name || '').trim();
+    const value = typeof credential?.value === 'string' ? credential.value : '';
+    if (!isRuntimeCredentialName(name) || !value) continue;
+    updates[name] = value;
+    nextNames.push(name);
+  }
+
+  const nextNameSet = new Set(nextNames);
+  for (const name of previousNames) {
+    if (!nextNameSet.has(name)) updates[name] = '';
+  }
+  updates[TICLAWK_CREDENTIAL_NAMES] = nextNames.join(',');
+
+  persistConfig(updates);
+  return {
+    saved: nextNames.length,
+    removed: [...previousNames].filter((name) => !nextNameSet.has(name)).length,
+  };
+}