@percena/weft 0.4.0-next.4 → 0.4.0-next.6

package/dist/chat.cjs

@@ -7119,27 +7119,6 @@ var import_react18 = require("react");
 var import_react19 = require("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]) {
@@ -7147,12 +7126,6 @@ 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);
@@ -7930,879 +7903,30 @@ function TimelineAgentChatPanel({
 var import_react21 = require("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 = (0, import_react21.useRef)(options.onTokenExpired);
-  onTokenExpiredRef.current = options.onTokenExpired;
-  const tokenRef = (0, import_react21.useRef)(options.token);
-  tokenRef.current = options.token;
+  const createRuntimeRef = (0, import_react21.useRef)(options.createRuntime);
+  createRuntimeRef.current = options.createRuntime;
   const runtime = (0, import_react21.useMemo)(() => {
     return createDeferredAgentRuntime({
-      provider: "flitro",
-      runtimeKind: "app-server",
+      provider: options.provider ?? "agent",
+      runtimeKind: options.runtimeKind ?? "app-server",
       sessionId: options.sessionId,
-      createRuntime: () => createFlitroEmbedRuntime({
-        baseUrl: options.server,
-        token: tokenRef.current,
-        sessionId: options.sessionId,
-        onTokenExpired: () => onTokenExpiredRef.current?.()
-      })
+      createRuntime: () => createRuntimeRef.current()
     });
-  }, [options.server, options.sessionId]);
+  }, [options.sessionId]);
   (0, import_react21.useEffect)(() => {
     return () => {
       void runtime.disposeIfCreated();
     };
   }, [runtime]);
-  return { runtime, sessionId: options.sessionId, server: options.server };
+  return { runtime, sessionId: options.sessionId };
 }
 function createDeferredAgentRuntime(options) {
   let runtime = null;