@percena/weft 0.4.0-next.3 → 0.4.0-next.5

package/dist/chat.js

@@ -7043,6 +7043,27 @@ import { useState as useState22 } from "react";
 import { useCallback as useCallback9, useEffect as useEffect9, useMemo as useMemo8, useRef as useRef8, useState as useState12 } from "react";
 
 // ../packages/timeline/dist/index.js
+function createTimelineCursor(cursor) {
+  return {
+    epoch: cursor.epoch,
+    afterSeq: cursor.afterSeq
+  };
+}
+function fetchTimeline(timeline, request = {}) {
+  const ordered = sortTimeline(timeline);
+  const cursor = request.cursor ?? cursorFromTimelineStart(ordered);
+  const items = ordered.filter((item) => item.epoch === cursor.epoch && item.seq > cursor.afterSeq).slice(0, request.limit);
+  const lastSeq = items.at(-1)?.seq ?? cursor.afterSeq;
+  const firstSeq = items[0]?.seq;
+  return {
+    items,
+    nextCursor: {
+      epoch: cursor.epoch,
+      afterSeq: lastSeq
+    },
+    hasGap: firstSeq !== void 0 && firstSeq > cursor.afterSeq + 1
+  };
+}
 function mergeTimeline(existing, incoming) {
   const byKey = /* @__PURE__ */ new Map();
   for (const item of [...existing, ...incoming]) {
@@ -7050,6 +7071,12 @@ function mergeTimeline(existing, incoming) {
   }
   return sortTimeline([...byKey.values()]);
 }
+function cursorFromTimelineStart(timeline) {
+  return {
+    epoch: timeline[0]?.epoch ?? "default",
+    afterSeq: 0
+  };
+}
 function sortTimeline(timeline) {
   return [...timeline].sort((left, right) => {
     if (left.epoch !== right.epoch) return left.epoch.localeCompare(right.epoch);
@@ -7823,8 +7850,960 @@ function TimelineAgentChatPanel({
   ] });
 }
 
-// src/chat.ts
-import { useAgentSession } from "@percena/weft-react";
+// ../packages/react/src/use-agent-session.ts
+import { useEffect as useEffect10, useMemo as useMemo9, useRef as useRef9 } from "react";
+
+// ../packages/runtime-core/dist/index.js
+var RUNTIME_KINDS = ["native-sdk", "app-server", "compatible-sdk", "cli-fallback"];
+var initialRuntimeState = {
+  status: "idle",
+  acceptedMessages: [],
+  queuedMessages: []
+};
+function reduceRuntimeState(state = initialRuntimeState, action) {
+  switch (action.type) {
+    case "preflight_start":
+      return { ...state, status: "preflighting", lastError: void 0 };
+    case "preflight_ok":
+      return { ...state, status: "ready", lastError: void 0 };
+    case "preflight_error":
+      return { ...state, status: "failed", lastError: action.error };
+    case "starting":
+      if (state.status === "ready" || state.status === "idle") {
+        return { ...state, status: "starting" };
+      }
+      return state;
+    case "send_message":
+      if (state.status === "running" || state.status === "waiting_for_permission") {
+        return {
+          ...state,
+          queuedMessages: [...state.queuedMessages, action.message]
+        };
+      }
+      return {
+        ...state,
+        status: "running",
+        acceptedMessages: [...state.acceptedMessages, action.message]
+      };
+    case "permission_request":
+      return {
+        ...state,
+        status: "waiting_for_permission",
+        waitingPermissionRequestId: action.requestId
+      };
+    case "permission_response":
+      return {
+        ...state,
+        status: "running",
+        waitingPermissionRequestId: void 0
+      };
+    case "turn_completed":
+      if (state.status === "running") {
+        return { ...state, status: "turn_completed" };
+      }
+      return state;
+    case "complete": {
+      if (state.status === "turn_completed") {
+        const [nextMessage2, ...remaining2] = state.queuedMessages;
+        if (nextMessage2) {
+          return {
+            ...state,
+            status: "running",
+            acceptedMessages: [...state.acceptedMessages, nextMessage2],
+            queuedMessages: remaining2
+          };
+        }
+        return { ...state, status: "ready" };
+      }
+      const [nextMessage, ...remaining] = state.queuedMessages;
+      if (nextMessage) {
+        return {
+          ...state,
+          status: "running",
+          acceptedMessages: [...state.acceptedMessages, nextMessage],
+          queuedMessages: remaining
+        };
+      }
+      return { ...state, status: "ready" };
+    }
+    case "abort":
+      return {
+        ...state,
+        status: "ready",
+        lastError: action.reason,
+        queuedMessages: [],
+        waitingPermissionRequestId: void 0
+      };
+    case "error":
+      return { ...state, status: "failed", lastError: action.error };
+    case "dispose":
+      return {
+        ...state,
+        status: "disposed",
+        queuedMessages: [],
+        waitingPermissionRequestId: void 0
+      };
+  }
+}
+function createRuntimeExtensionContext(context = {}) {
+  return {
+    policy: context.policy,
+    sources: context.sources ? { enabledSourceSlugs: unique(context.sources.enabledSourceSlugs) } : void 0,
+    skills: context.skills ? { activeSkillSlugs: unique(context.skills.activeSkillSlugs) } : void 0,
+    commandOrigin: context.commandOrigin,
+    hostServices: context.hostServices
+  };
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function findCandidate(candidates, kind) {
+  return candidates.find((candidate) => candidate.kind === kind);
+}
+function defaultRuntimeKindOrder(provider) {
+  if (provider === "codex") {
+    return ["app-server", "native-sdk", "compatible-sdk", "cli-fallback"];
+  }
+  return RUNTIME_KINDS;
+}
+function firstAvailableCandidate(candidates, provider) {
+  for (const kind of defaultRuntimeKindOrder(provider)) {
+    const candidate = findCandidate(candidates, kind);
+    if (candidate?.available) return candidate;
+  }
+  return void 0;
+}
+function selectRuntimeCandidate(options) {
+  const preferred = options.preferredRuntime ? findCandidate(options.candidates, options.preferredRuntime) : void 0;
+  if (preferred?.available) {
+    return { selected: preferred.kind, fallback: false };
+  }
+  if (preferred && options.allowFallback !== true) {
+    return {
+      fallback: false,
+      error: preferred.reason ?? `${preferred.kind} runtime is unavailable`
+    };
+  }
+  const selected = firstAvailableCandidate(options.candidates, options.provider);
+  if (!selected) {
+    return {
+      fallback: false,
+      error: options.candidates.map((candidate) => candidate.reason).filter(Boolean).join("; ") || "No runtime candidates are available"
+    };
+  }
+  const fallback = Boolean(preferred && selected.kind !== preferred.kind);
+  return {
+    selected: selected.kind,
+    fallback,
+    fallbackReason: fallback ? preferred?.reason ?? `${preferred?.kind ?? "preferred"} runtime is unavailable` : void 0
+  };
+}
+function createRuntimeCapabilityReport(options) {
+  const selection = selectRuntimeCandidate(options);
+  const extensionCapabilities = normalizeExtensionCapabilities(options.extensionCapabilities);
+  return {
+    provider: options.provider,
+    candidates: options.candidates,
+    preferredRuntime: options.preferredRuntime,
+    allowFallback: options.allowFallback === true,
+    auth: options.auth,
+    ...extensionCapabilities,
+    ...selection
+  };
+}
+function normalizeExtensionCapabilities(capabilities = {}) {
+  return {
+    policyCapabilities: capabilities.policy ?? {
+      supported: false,
+      modes: [],
+      approvals: false,
+      toolPolicy: false
+    },
+    sourceCapabilities: capabilities.sources ?? {
+      supported: false
+    },
+    skillCapabilities: capabilities.skills ?? {
+      supported: false
+    },
+    automationCapabilities: capabilities.automations ?? {
+      supported: false,
+      eventBus: false,
+      schedulerHost: false,
+      promptAction: false,
+      webhookAction: false
+    },
+    hostToolCapabilities: capabilities.hostTools ?? {
+      supported: false,
+      sessionTools: false,
+      workflowTransitions: false,
+      browserActions: false,
+      metadataWrites: false
+    }
+  };
+}
+
+// ../packages/client/dist/index.js
+var FlitroHttpClient = class {
+  baseUrl;
+  timeout;
+  apiKey;
+  tenantId;
+  onTokenExpired;
+  token;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.timeout = options.timeout ?? 3e4;
+    this.apiKey = options.apiKey ?? "";
+    this.tenantId = options.tenantId ?? "";
+    this.token = options.token ?? "";
+    this.onTokenExpired = options.onTokenExpired;
+  }
+  /** Current Authorization bearer (scoped token wins over apiKey). */
+  getBearerToken() {
+    return this.token || this.apiKey;
+  }
+  /** Replace the scoped token (e.g. after a host-backend refresh). */
+  setToken(token) {
+    this.token = token;
+  }
+  buildHeaders() {
+    const headers = { "Content-Type": "application/json" };
+    const bearer = this.getBearerToken();
+    if (bearer) headers["Authorization"] = `Bearer ${bearer}`;
+    if (!this.token && this.tenantId) headers["X-Tenant-ID"] = this.tenantId;
+    return headers;
+  }
+  async preflight() {
+    return this.get("/v1/capabilities");
+  }
+  async health() {
+    return this.get("/v1/health");
+  }
+  async createSession(options) {
+    return this.post("/v1/sessions", {
+      title: options?.title ?? "Weft session",
+      model: options?.model,
+      skill_names: options?.skillNames,
+      mcp_server_names: options?.mcpServerNames
+    });
+  }
+  async getSession(sessionId) {
+    return this.get(`/v1/sessions/${encodeURIComponent(sessionId)}`);
+  }
+  async sendMessage(sessionId, message, options) {
+    const budget = options?.budget ? {
+      max_steps: options.budget.maxSteps,
+      max_tokens: options.budget.maxTokens,
+      max_wall_time_sec: options.budget.maxWallTimeSec
+    } : void 0;
+    return this.post(`/v1/sessions/${encodeURIComponent(sessionId)}/runs`, {
+      message,
+      model: options?.model,
+      skill_names: options?.skillNames,
+      mcp_server_names: options?.mcpServerNames,
+      tool_names: options?.toolNames,
+      approval_policy: options?.approvalPolicy,
+      execution_mode: options?.executionMode,
+      workspace_id: options?.workspaceId,
+      budget
+    });
+  }
+  async cancelRun(runId) {
+    return this.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {});
+  }
+  async resumeTool(runId, resumeData) {
+    return this.post(
+      `/v1/runs/${encodeURIComponent(runId)}/resume-tool`,
+      { resume_data: resumeData }
+    );
+  }
+  async respondToPermission(sessionId, requestId, allowed, options) {
+    return this.post(
+      `/v1/sessions/${encodeURIComponent(sessionId)}/permission-response`,
+      { requestId, allowed, remember: options?.remember, text: options?.text, answer: options?.answer }
+    );
+  }
+  async patchSession(sessionId, patch) {
+    return this.patch(
+      `/v1/sessions/${encodeURIComponent(sessionId)}`,
+      patch
+    );
+  }
+  async listModels() {
+    return this.get("/v1/models");
+  }
+  async fetchTimeline(sessionId, afterSeq, limit) {
+    const params = new URLSearchParams();
+    if (afterSeq !== void 0) params.set("after_seq", String(afterSeq));
+    if (limit !== void 0) params.set("limit", String(limit));
+    const qs = params.toString();
+    const url = `/v1/sessions/${encodeURIComponent(sessionId)}/timeline/fetch${qs ? `?${qs}` : ""}`;
+    return this.get(url);
+  }
+  /** Returns the SSE stream URL for a session's canonical timeline. */
+  sessionTimelineUrl(sessionId) {
+    return `${this.baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}/timeline`;
+  }
+  async get(path) {
+    return this.request("GET", path, void 0);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async request(method, path, body, isRetry = false) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: this.buildHeaders(),
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (response.status === 401 && this.token && this.onTokenExpired && !isRetry) {
+        const fresh = await this.onTokenExpired();
+        if (fresh) {
+          this.token = fresh;
+          return this.request(method, path, body, true);
+        }
+      }
+      if (!response.ok) {
+        let errorMsg = `Flitro HTTP ${response.status}`;
+        try {
+          const errBody = await response.json();
+          if (errBody.error) errorMsg = `${errorMsg}: ${errBody.error}`;
+        } catch {
+        }
+        throw new Error(errorMsg);
+      }
+      return response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+var FlitroFetchSseTimelineStream = class {
+  listeners = /* @__PURE__ */ new Set();
+  abortController = null;
+  connected = false;
+  disposed = false;
+  afterSeq;
+  reconnectAttempts = 0;
+  tokenOverride = "";
+  getBearerToken;
+  onTokenExpired;
+  options;
+  constructor(options) {
+    this.afterSeq = options.initialAfterSeq ?? 0;
+    this.getBearerToken = options.getBearerToken;
+    this.onTokenExpired = options.onTokenExpired;
+    this.options = {
+      url: options.url,
+      apiKey: options.apiKey ?? "",
+      tenantId: options.tenantId ?? "",
+      reconnectDelayMs: options.reconnectDelayMs ?? 1500,
+      maxReconnectAttempts: options.maxReconnectAttempts ?? 20,
+      initialAfterSeq: this.afterSeq,
+      now: options.now ?? (() => Date.now())
+    };
+  }
+  connect(onEvent, onError, onClose) {
+    this.disposed = false;
+    this.listeners.add({ onEvent, onError, onClose });
+    if (!this.connected) {
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this.startFetch();
+    }
+  }
+  disconnect() {
+    this.disposed = true;
+    this.connected = false;
+    this.abortController?.abort();
+    for (const listener of this.listeners) {
+      listener.onClose?.();
+    }
+    this.listeners.clear();
+  }
+  isConnected() {
+    return this.connected && !this.disposed;
+  }
+  buildUrl() {
+    let url = this.options.url;
+    if (this.afterSeq > 0) {
+      url += (url.includes("?") ? "&" : "?") + `after_seq=${this.afterSeq}`;
+    }
+    return url;
+  }
+  buildHeaders() {
+    const h = { Accept: "text/event-stream" };
+    const bearer = this.tokenOverride || this.getBearerToken?.() || this.options.apiKey;
+    if (bearer) h["Authorization"] = `Bearer ${bearer}`;
+    if (this.options.tenantId) h["X-Tenant-ID"] = this.options.tenantId;
+    return h;
+  }
+  async startFetch() {
+    if (this.disposed) return;
+    this.abortController = new AbortController();
+    try {
+      const response = await fetch(this.buildUrl(), {
+        headers: this.buildHeaders(),
+        signal: this.abortController.signal
+      });
+      if (response.status === 401 && this.onTokenExpired) {
+        const fresh = await this.onTokenExpired();
+        if (fresh) this.tokenOverride = fresh;
+      }
+      if (!response.ok || !response.body) {
+        throw new Error(`Flitro SSE: HTTP ${response.status}`);
+      }
+      this.reconnectAttempts = 0;
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const envelopes = parseSseBuffer(buffer);
+        buffer = envelopes.remainder;
+        for (const envelope of envelopes.items) {
+          if (envelope.seq > this.afterSeq) {
+            this.afterSeq = envelope.seq;
+          }
+          for (const listener of this.listeners) {
+            listener.onEvent(envelope);
+          }
+        }
+      }
+      if (!this.disposed) {
+        this.connected = false;
+        this.scheduleReconnect();
+      }
+    } catch (err) {
+      if (this.disposed) return;
+      if (err instanceof Error && err.name === "AbortError") return;
+      this.connected = false;
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.disposed) return;
+    if (this.reconnectAttempts >= this.options.maxReconnectAttempts) {
+      this.emitError(new Error(`Flitro SSE: max reconnect attempts reached`));
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(this.options.reconnectDelayMs * this.reconnectAttempts, 3e4);
+    setTimeout(() => {
+      this.connected = true;
+      this.startFetch();
+    }, delay);
+  }
+  emitError(err) {
+    for (const listener of this.listeners) listener.onError?.(err);
+  }
+};
+function parseSseBuffer(buffer) {
+  const items = [];
+  const blocks = buffer.split("\n\n");
+  const remainder = blocks.pop() ?? "";
+  for (const block of blocks) {
+    let eventType = "";
+    let data = "";
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event: ")) {
+        eventType = line.slice(7).trim();
+      } else if (line.startsWith("data: ")) {
+        data = line.slice(6).trim();
+      }
+    }
+    if (eventType === "timeline" && data) {
+      try {
+        items.push(JSON.parse(data));
+      } catch {
+      }
+    }
+  }
+  return { items, remainder };
+}
+function createFlitroTimelineStream(options) {
+  return new FlitroFetchSseTimelineStream(options);
+}
+
+// ../packages/provider-flitro/dist/index.js
+function mapPermissionModeToApprovalPolicy(mode) {
+  if (mode === "allow-all") return "auto";
+  if (mode === "safe") return "never";
+  if (mode === "ask") return "on-request";
+  return void 0;
+}
+function createFlitroDriver(options) {
+  let activeRunId;
+  return {
+    async sendMessage(input, _sequencer) {
+      const run = await options.client.sendMessage(
+        options.sessionId,
+        input.message,
+        {
+          model: input.options?.model ?? options.model,
+          skillNames: options.skillNames,
+          mcpServerNames: options.mcpServerNames,
+          // Per-message permission choice (from the chat panel selector) wins
+          // over the runtime's creation-time default.
+          approvalPolicy: mapPermissionModeToApprovalPolicy(input.options?.permissionMode) ?? options.approvalPolicy
+        }
+      );
+      activeRunId = run.run_id;
+    },
+    async abort(reason) {
+      if (activeRunId) {
+        await options.client.cancelRun(activeRunId).catch(() => {
+        });
+        activeRunId = void 0;
+      }
+    },
+    async respondToPermission(requestId, allowed, remember) {
+      await options.client.respondToPermission(options.sessionId, requestId, allowed, {
+        remember
+      });
+    },
+    async resumeTool(runId, resumeData) {
+      await options.client.resumeTool(runId, resumeData);
+    },
+    async dispose() {
+      if (activeRunId) {
+        await options.client.cancelRun(activeRunId).catch(() => {
+        });
+        activeRunId = void 0;
+      }
+    }
+  };
+}
+function createFlitroRuntimeCapabilityReport(options) {
+  const appServerAvailable = options.candidates.some((c) => c.kind === "app-server" && c.available);
+  return createRuntimeCapabilityReport({
+    provider: "flitro",
+    candidates: options.candidates,
+    preferredRuntime: "app-server",
+    allowFallback: options.allowFallback,
+    auth: options.auth,
+    extensionCapabilities: {
+      policy: {
+        supported: true,
+        degraded: !appServerAvailable || void 0,
+        modes: ["safe", "ask", "allow-all"],
+        approvals: appServerAvailable,
+        toolPolicy: appServerAvailable,
+        reason: appServerAvailable ? void 0 : "Flitro server is unavailable"
+      },
+      sources: {
+        supported: appServerAvailable,
+        registry: appServerAvailable,
+        mcpTools: appServerAvailable,
+        credentialGateway: false,
+        reason: appServerAvailable ? void 0 : "Source tools require a running Flitro server"
+      },
+      skills: {
+        supported: appServerAvailable,
+        registry: appServerAvailable,
+        activationPlan: appServerAvailable,
+        scopedPolicy: appServerAvailable,
+        reason: appServerAvailable ? void 0 : "Skill activation requires a running Flitro server"
+      },
+      automations: {
+        supported: appServerAvailable,
+        degraded: !appServerAvailable || void 0,
+        eventBus: appServerAvailable,
+        schedulerHost: appServerAvailable,
+        promptAction: appServerAvailable,
+        webhookAction: false,
+        reason: appServerAvailable ? void 0 : "Automations require a running Flitro server"
+      },
+      hostTools: {
+        supported: appServerAvailable,
+        sessionTools: false,
+        workflowTransitions: false,
+        browserActions: false,
+        metadataWrites: appServerAvailable
+      }
+    }
+  });
+}
+function createFlitroProviderRuntime(options) {
+  const report = createFlitroRuntimeCapabilityReport(options);
+  const extensions = createRuntimeExtensionContext(options.extensions);
+  const client = new FlitroHttpClient(options.server);
+  let resolvedSessionId = options.sessionId ?? "";
+  let epoch = options.epoch ?? (resolvedSessionId ? `flitro-${resolvedSessionId}` : "flitro-pending");
+  const now = options.now ?? (() => Date.now());
+  const timeline = [];
+  const seenTimelineKeys = /* @__PURE__ */ new Set();
+  const stream = new PushTimelineStream();
+  let state = initialRuntimeState;
+  let runtimeDriver = options.driver;
+  let sseStream;
+  const pendingMessages = [];
+  function dispatch(action) {
+    state = reduceRuntimeState(state, action);
+  }
+  function syncStateFromEnvelope(envelope) {
+    const item = envelope.item;
+    if (item.type === "permission_requested") {
+      dispatch({ type: "permission_request", requestId: item.request.requestId });
+    } else if (item.type === "permission_resolved") {
+      dispatch({ type: "permission_response" });
+    } else if (item.type === "turn_completed") {
+      dispatch({ type: "turn_completed" });
+      dispatch({ type: "complete" });
+      void sendNextPendingMessage();
+    } else if (item.type === "turn_failed") {
+      const err = item.error;
+      dispatch({ type: "error", error: err?.message ?? "turn failed" });
+    } else if (item.type === "tool_suspended") {
+      dispatch({ type: "permission_request", requestId: `tool-suspend:${item.callId}` });
+    } else if (item.type === "tool_resumed") {
+      dispatch({ type: "permission_response" });
+    } else if (item.type === "session_status") {
+      if (item.status === "running") {
+        dispatch({ type: "starting" });
+      } else if (item.status === "ended") {
+        dispatch({ type: "abort" });
+      }
+    }
+  }
+  function appendEnvelope(envelope) {
+    if (envelope.seq > 0) {
+      const key = `${envelope.epoch || envelope.sessionId || "unknown"}:${envelope.seq}`;
+      if (seenTimelineKeys.has(key)) return;
+      seenTimelineKeys.add(key);
+    }
+    syncStateFromEnvelope(envelope);
+    timeline.push(envelope);
+    stream.emit(envelope);
+  }
+  function appendFailure(message) {
+    const item = { type: "turn_failed", turnId: "provider-runtime", error: { message } };
+    const envelope = {
+      sessionId: resolvedSessionId,
+      provider: "flitro",
+      seq: timeline.length + 1,
+      epoch,
+      timestamp: now(),
+      item
+    };
+    appendEnvelope(envelope);
+  }
+  function getDriver() {
+    if (runtimeDriver) return runtimeDriver;
+    runtimeDriver = createFlitroDriver({
+      client,
+      sessionId: resolvedSessionId,
+      model: options.model,
+      skillNames: options.skillNames,
+      mcpServerNames: options.mcpServerNames,
+      approvalPolicy: options.approvalPolicy
+    });
+    return runtimeDriver;
+  }
+  async function sendToFlitro(message, sendOptions) {
+    const driver = getDriver();
+    try {
+      await driver.sendMessage({ message, options: sendOptions }, {
+        append: (item, rawRef) => {
+          const envelope = {
+            sessionId: resolvedSessionId,
+            provider: "flitro",
+            seq: timeline.length + 1,
+            epoch,
+            timestamp: now(),
+            item,
+            rawRef
+          };
+          appendEnvelope(envelope);
+          return envelope;
+        }
+      });
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      dispatch({ type: "error", error });
+      appendFailure(error);
+      throw err;
+    }
+  }
+  async function sendNextPendingMessage() {
+    const next = pendingMessages.shift();
+    if (!next) return;
+    try {
+      await sendToFlitro(next.message, next.options);
+    } catch {
+    }
+  }
+  async function ensureSession() {
+    if (resolvedSessionId) return;
+    const session = await client.createSession({
+      model: options.model,
+      skillNames: options.skillNames,
+      mcpServerNames: options.mcpServerNames
+    });
+    resolvedSessionId = session.session_id;
+    if (!options.epoch) {
+      epoch = `flitro-${resolvedSessionId}`;
+    }
+    connectSse();
+  }
+  function connectSse() {
+    if (!resolvedSessionId || sseStream) return;
+    sseStream = createFlitroTimelineStream({
+      url: client.sessionTimelineUrl(resolvedSessionId),
+      apiKey: options.server.apiKey,
+      tenantId: options.server.tenantId,
+      // Scoped embed tokens rotate; always read the client's current bearer
+      // and propagate refreshed tokens back to it.
+      getBearerToken: () => client.getBearerToken(),
+      onTokenExpired: options.server.onTokenExpired ? async () => {
+        const fresh = await options.server.onTokenExpired?.();
+        if (fresh) client.setToken(fresh);
+        return fresh;
+      } : void 0
+    });
+    sseStream.connect(
+      // The client package types `item` as unknown; the server emits the
+      // canonical Weft envelope, so this is the narrowing point.
+      (envelope) => appendEnvelope(envelope),
+      (_err) => {
+      }
+    );
+  }
+  if (resolvedSessionId) {
+    connectSse();
+  }
+  return {
+    get sessionId() {
+      return resolvedSessionId;
+    },
+    provider: "flitro",
+    runtimeKind: report.selected ?? "app-server",
+    events: stream,
+    commands: {
+      async sendMessage(message, sendOptions) {
+        await ensureSession();
+        const shouldQueue = state.status === "running" || state.status === "waiting_for_permission";
+        dispatch({ type: "send_message", message });
+        if (shouldQueue) {
+          pendingMessages.push({ message, options: sendOptions });
+          return;
+        }
+        await sendToFlitro(message, sendOptions);
+      },
+      async abort(reason) {
+        dispatch({ type: "abort", reason });
+        pendingMessages.length = 0;
+        await runtimeDriver?.abort?.(reason);
+      },
+      async respondToPermission(requestId, allowed, remember) {
+        await getDriver().respondToPermission?.(requestId, allowed, remember);
+        dispatch({ type: "permission_response" });
+      },
+      async resumeTool(runId, resumeData) {
+        await getDriver().resumeTool?.(runId, resumeData);
+      },
+      async dispose() {
+        dispatch({ type: "dispose" });
+        pendingMessages.length = 0;
+        sseStream?.disconnect();
+        sseStream = void 0;
+        await runtimeDriver?.dispose?.();
+      }
+    },
+    async preflight() {
+      dispatch({ type: "preflight_start" });
+      if (!report.selected) {
+        dispatch({ type: "preflight_error", error: report.error ?? "No runtime selected" });
+      } else {
+        dispatch({ type: "preflight_ok" });
+      }
+      const capItem = { type: "runtime_capability_report", report };
+      const capEnvelope = {
+        sessionId: resolvedSessionId,
+        provider: "flitro",
+        seq: timeline.length + 1,
+        epoch,
+        timestamp: now(),
+        item: capItem
+      };
+      appendEnvelope(capEnvelope);
+      return report;
+    },
+    async fetchTimeline(request = {}) {
+      if (request.cursor?.epoch === epoch || !request.cursor) {
+        const localResult = fetchTimeline(timeline, request);
+        if (localResult.items.length > 0) return localResult;
+      }
+      if (resolvedSessionId) {
+        try {
+          const afterSeq = request.cursor?.afterSeq ?? 0;
+          const result = await client.fetchTimeline(resolvedSessionId, afterSeq, request.limit);
+          return {
+            items: result.items,
+            nextCursor: createTimelineCursor({
+              epoch: result.nextCursor.epoch,
+              afterSeq: result.nextCursor.afterSeq
+            }),
+            hasGap: result.hasGap
+          };
+        } catch {
+        }
+      }
+      return {
+        items: [],
+        nextCursor: createTimelineCursor({ epoch, afterSeq: 0 }),
+        hasGap: false
+      };
+    },
+    getState() {
+      return state;
+    }
+  };
+}
+function createFlitroEmbedRuntime(options) {
+  return createFlitroProviderRuntime({
+    server: {
+      baseUrl: options.baseUrl,
+      token: options.token,
+      onTokenExpired: options.onTokenExpired
+    },
+    sessionId: options.sessionId,
+    epoch: options.epoch,
+    now: options.now,
+    extensions: options.extensions,
+    candidates: [{ kind: "app-server", available: true }],
+    auth: { mode: "provider-owned", configured: true, source: "flitro-embed" }
+  });
+}
+var PushTimelineStream = class {
+  listeners = /* @__PURE__ */ new Set();
+  connect(onEvent, onError, onClose) {
+    this.listeners.add({ onEvent, onError, onClose });
+  }
+  disconnect() {
+    for (const l of this.listeners) l.onClose?.();
+    this.listeners.clear();
+  }
+  isConnected() {
+    return this.listeners.size > 0;
+  }
+  emit(event) {
+    for (const l of this.listeners) l.onEvent(event);
+  }
+};
+
+// ../packages/react/src/use-agent-session.ts
+function useAgentSession(options) {
+  const onTokenExpiredRef = useRef9(options.onTokenExpired);
+  onTokenExpiredRef.current = options.onTokenExpired;
+  const tokenRef = useRef9(options.token);
+  tokenRef.current = options.token;
+  const runtime = useMemo9(() => {
+    return createDeferredAgentRuntime({
+      provider: "flitro",
+      runtimeKind: "app-server",
+      sessionId: options.sessionId,
+      createRuntime: () => createFlitroEmbedRuntime({
+        baseUrl: options.server,
+        token: tokenRef.current,
+        sessionId: options.sessionId,
+        onTokenExpired: () => onTokenExpiredRef.current?.()
+      })
+    });
+  }, [options.server, options.sessionId]);
+  useEffect10(() => {
+    return () => {
+      void runtime.disposeIfCreated();
+    };
+  }, [runtime]);
+  return { runtime, sessionId: options.sessionId, server: options.server };
+}
+function createDeferredAgentRuntime(options) {
+  let runtime = null;
+  let disposed = false;
+  const getRuntime = () => {
+    if (disposed) {
+      throw new Error("Agent runtime has been disposed");
+    }
+    runtime ??= options.createRuntime();
+    return runtime;
+  };
+  return {
+    get sessionId() {
+      return runtime?.sessionId ?? options.sessionId;
+    },
+    get provider() {
+      return runtime?.provider ?? options.provider;
+    },
+    get runtimeKind() {
+      return runtime?.runtimeKind ?? options.runtimeKind;
+    },
+    events: {
+      connect(onEvent, onError, onClose) {
+        getRuntime().events.connect(onEvent, onError, onClose);
+      },
+      disconnect() {
+        runtime?.events.disconnect();
+      },
+      isConnected() {
+        return runtime?.events.isConnected() ?? false;
+      }
+    },
+    commands: {
+      sendMessage(message, sendOptions) {
+        return getRuntime().commands.sendMessage(message, sendOptions);
+      },
+      abort(reason) {
+        return getRuntime().commands.abort(reason);
+      },
+      respondToPermission(requestId, allowed, remember) {
+        return getRuntime().commands.respondToPermission(requestId, allowed, remember);
+      },
+      async resumeTool(runId, resumeData) {
+        const commands = getRuntime().commands;
+        if (!commands.resumeTool) {
+          throw new Error(`resumeTool is not supported by the ${options.provider} runtime`);
+        }
+        await commands.resumeTool(runId, resumeData);
+      },
+      dispose() {
+        disposed = true;
+        const current = runtime;
+        runtime = null;
+        return current?.commands.dispose() ?? Promise.resolve();
+      }
+    },
+    preflight() {
+      return getRuntime().preflight();
+    },
+    fetchTimeline(request) {
+      return getRuntime().fetchTimeline(request);
+    },
+    getState() {
+      return runtime?.getState() ?? {
+        status: initialRuntimeState.status,
+        acceptedMessages: [],
+        queuedMessages: []
+      };
+    },
+    async disposeIfCreated() {
+      if (!runtime) return;
+      const current = runtime;
+      runtime = null;
+      await current.commands.dispose();
+    }
+  };
+}
 export {
   ActivityDetailsPanel,
   ActivityInspector,