@agent-native/core 0.114.4 → 0.114.5

package/corpus/templates/clips/desktop/src/lib/transcription-engine.ts

@@ -224,6 +224,35 @@ function browserLocale(): string {
   return navigator.language || "en-US";
 }
 
+function isUnavailableSelectedMicrophoneError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /selected microphone .+ is not available/i.test(message);
+}
+
+function transcriptionStartError(
+  error: unknown,
+  selectedMicrophoneUnavailable: boolean,
+): Error {
+  if (selectedMicrophoneUnavailable) {
+    return new Error(
+      "Your selected microphone is no longer available. Clips tried your Mac's default microphone, but notes still could not start. Choose an available microphone in Clips settings, then try again.",
+    );
+  }
+
+  const message = error instanceof Error ? error.message : String(error);
+  if (
+    /screencapturekit|voiceprocessingi|microphone|audio capture|local .*capture/i.test(
+      message,
+    )
+  ) {
+    return new Error(
+      "Clips could not start local audio capture. Check that Clips has Microphone and Screen Recording access in System Settings, then try again.",
+    );
+  }
+
+  return new Error("Clips could not start local transcription. Try again.");
+}
+
 export function recordingTranscriptionLanguage(): string | null {
   return null;
 }
@@ -298,12 +327,46 @@ export async function startTranscriptionEngine(opts: {
     );
     return "whisper";
   } catch (err) {
+    let fallbackMic = opts.mic;
+    const selectedMicrophoneUnavailable =
+      Boolean(opts.mic) && isUnavailableSelectedMicrophoneError(err);
     console.warn(
       "[transcription] whisper mic+system failed, falling back to mic-only:",
       err,
     );
-    await restartTranscriptionEngine("macos-native", opts.mic);
-    return "macos-native";
+    if (selectedMicrophoneUnavailable) {
+      console.warn(
+        "[transcription] selected microphone is unavailable; retrying with the macOS default input:",
+        err,
+      );
+      try {
+        await restartTranscriptionEngine(
+          "whisper",
+          undefined,
+          captureSystem,
+          voiceProcessing,
+          emitPartials,
+        );
+        return "whisper";
+      } catch (defaultMicErr) {
+        console.warn(
+          "[transcription] default mic+system capture failed, falling back to default mic-only:",
+          defaultMicErr,
+        );
+        fallbackMic = undefined;
+      }
+    }
+    try {
+      await restartTranscriptionEngine("macos-native", fallbackMic);
+      return "macos-native";
+    } catch (fallbackErr) {
+      throw transcriptionStartError(
+        fallbackErr,
+        selectedMicrophoneUnavailable ||
+          (Boolean(opts.mic) &&
+            isUnavailableSelectedMicrophoneError(fallbackErr)),
+      );
+    }
   }
 }
 

package/corpus/templates/clips/server/db/schema.ts

@@ -425,6 +425,9 @@ export const meetings = table("clips_meetings", {
   })
     .notNull()
     .default("idle"),
+  shareTranscript: integer("share_transcript", { mode: "boolean" })
+    .notNull()
+    .default(false),
   summaryMd: text("summary_md").notNull().default(""),
   // JSON array of `{ text }` bullets.
   bulletsJson: text("bullets_json").notNull().default("[]"),

package/corpus/templates/clips/server/lib/public-agent-context.ts

@@ -11,6 +11,7 @@ import { getRequestURL, setResponseHeader, type H3Event } from "h3";
 import {
   buildAgentApiUrls,
   buildRecommendedFrames,
+  getAgentClipReadiness,
   CLIP_AGENT_ACCESS_TOKEN_PREFIX,
   CLIPS_AGENT_ACCESS_PARAM,
   CLIP_AGENT_CONTEXT_VERSION,
@@ -538,18 +539,24 @@ export function buildPublicAgentContext({
   const publicPageUrl = `${requestUrl.origin}${getServerAppBasePath()}/share/${encodeURIComponent(recording.id)}`;
   const isLoomSource = isLoomRecordingSource(recording);
   const isLoomEmbedBacked = isLoomEmbedBackedRecording(recording);
-  const suggestedFrames = isLoomEmbedBacked
-    ? []
-    : buildRecommendedFrames({
-        durationMs: recording.durationMs,
-        chapters,
-        segments: agentSegments,
-      }).map((frame) => ({
-        ...frame,
-        url: api.frameUrl(frame.atMs),
-      }));
+  const agentReadiness = getAgentClipReadiness(recording.status);
+  const clipIsReady = agentReadiness.state === "ready";
+  const suggestedFrames =
+    !clipIsReady || isLoomEmbedBacked
+      ? []
+      : buildRecommendedFrames({
+          durationMs: recording.durationMs,
+          chapters,
+          segments: agentSegments,
+        }).map((frame) => ({
+          ...frame,
+          url: api.frameUrl(frame.atMs),
+        }));
   const instructions = [
-    "Use transcript.segments for timestamped spoken context.",
+    ...(agentReadiness.instruction ? [agentReadiness.instruction] : []),
+    ...(clipIsReady
+      ? ["Use transcript.segments for timestamped spoken context."]
+      : []),
     ...transcriptStatusInstructions(transcript),
     ...(bugReport
       ? [
@@ -561,15 +568,17 @@ export function buildPublicAgentContext({
           "Use browserDiagnostics.consoleLogs for the redacted console stream (all levels: debug/log/info/warn/error) and browserDiagnostics.networkRequests for the fetch/XHR requests (method, sanitized URL, status, duration) captured during the recording. browserDiagnostics.consoleIssues highlights just the warnings/errors, and browserDiagnostics.failedNetworkRequests highlights failed requests.",
         ]
       : []),
-    ...(isLoomEmbedBacked
-      ? [
-          "This clip is a legacy Loom embed import; frame extraction is not available through Clips until it is reimported as a Clips-hosted video.",
-        ]
-      : [
-          "This clip is readable as both text (transcript) and images (JPEG frames) — you can hear AND see it.",
-          "To SEE the screen, GET apis.frame.urlTemplate with atMs (returns image/jpeg). Start with recommendedFrames, then fetch additional frames around transcript timestamps that matter for the task.",
-          "If you cannot load an image from a URL, you will only have the transcript — tell the user to open the clip in an image-capable agent (ChatGPT, Claude Code, Cursor, Codex) or to upload a frame image directly so you can see it.",
-        ]),
+    ...(!clipIsReady
+      ? []
+      : isLoomEmbedBacked
+        ? [
+            "This clip is a legacy Loom embed import; frame extraction is not available through Clips until it is reimported as a Clips-hosted video.",
+          ]
+        : [
+            "This clip is readable as both text (transcript) and images (JPEG frames) — you can hear AND see it.",
+            "To SEE the screen, GET apis.frame.urlTemplate with atMs (returns image/jpeg). Start with recommendedFrames, then fetch additional frames around transcript timestamps that matter for the task.",
+            "If you cannot load an image from a URL, you will only have the transcript — tell the user to open the clip in an image-capable agent (ChatGPT, Claude Code, Cursor, Codex) or to upload a frame image directly so you can see it.",
+          ]),
   ];
 
   return {
@@ -593,13 +602,14 @@ export function buildPublicAgentContext({
       hasAudio: Boolean(recording.hasAudio),
       hasCamera: Boolean(recording.hasCamera),
       status: recording.status,
+      agentReadiness,
       createdAt: recording.createdAt,
       updatedAt: recording.updatedAt,
     },
     apis: {
       context: { method: "GET", url: api.contextUrl },
       transcript: { method: "GET", url: api.transcriptUrl },
-      ...(isLoomEmbedBacked
+      ...(!clipIsReady || isLoomEmbedBacked
         ? {}
         : {
             frame: {

package/corpus/templates/clips/server/plugins/auth.ts

@@ -30,6 +30,7 @@ export default createAuthPlugin({
     "/__manifest",
     "/api/view-event",
     "/api/public-recording",
+    "/api/public-meeting",
     "/api/slack",
     "/api/agent-context.json",
     "/api/agent-transcript.json",

package/corpus/templates/clips/server/plugins/db.ts

@@ -64,6 +64,7 @@ async function retypeBooleanColumnsOnPostgres(): Promise<void> {
     ["recording_viewers", "counted_view", false],
     ["recording_viewers", "cta_clicked", false],
     ["meeting_participants", "is_organizer", false],
+    ["clips_meetings", "share_transcript", false],
   ];
   for (const [table, column, defaultTrue] of alters) {
     try {
@@ -833,6 +834,11 @@ const migrations = runMigrations(
         `CREATE UNIQUE INDEX IF NOT EXISTS recording_viewers_recording_viewer_key_unique_idx ON recording_viewers (recording_id, viewer_key)`,
       ].join("; "),
     },
+    {
+      version: 49,
+      name: "clips-meetings-share-transcript",
+      sql: `ALTER TABLE clips_meetings ADD COLUMN IF NOT EXISTS share_transcript INTEGER NOT NULL DEFAULT 0`,
+    },
   ],
   { table: "clips_migrations" },
 );

package/corpus/templates/clips/server/routes/api/agent-transcript.json.get.ts

@@ -12,7 +12,10 @@ import {
   type H3Event,
 } from "h3";
 
-import { buildAgentApiUrls } from "../../../shared/agent-context.js";
+import {
+  buildAgentApiUrls,
+  getAgentClipReadiness,
+} from "../../../shared/agent-context.js";
 import { isLoomEmbedBackedRecording } from "../../../shared/loom.js";
 import {
   applyAgentJsonHeaders,
@@ -50,6 +53,8 @@ export default defineEventHandler(async (event: H3Event) => {
     token: accessResult.access.apiToken,
   });
   const isLoomEmbedBacked = isLoomEmbedBackedRecording(recording);
+  const agentReadiness = getAgentClipReadiness(recording.status);
+  const clipIsReady = agentReadiness.state === "ready";
 
   return {
     type: "agent-native.clip.transcript",
@@ -57,11 +62,13 @@ export default defineEventHandler(async (event: H3Event) => {
       id: recording.id,
       title: recording.title,
       durationMs: recording.durationMs,
+      status: recording.status,
+      agentReadiness,
     },
     apis: {
       context: { method: "GET", url: api.contextUrl },
       transcript: { method: "GET", url: api.transcriptUrl },
-      ...(isLoomEmbedBacked
+      ...(!clipIsReady || isLoomEmbedBacked
         ? {}
         : {
             frame: {
@@ -79,6 +86,9 @@ export default defineEventHandler(async (event: H3Event) => {
       segments: agentSegments,
       segmentCount: agentSegments.length,
     },
-    instructions: transcriptStatusInstructions(transcript),
+    instructions: [
+      ...(agentReadiness.instruction ? [agentReadiness.instruction] : []),
+      ...transcriptStatusInstructions(transcript),
+    ],
   };
 });

package/corpus/templates/clips/server/routes/api/public-meeting.get.ts

@@ -0,0 +1,152 @@
+/**
+ * GET /api/public-meeting?id=<meetingId>
+ *
+ * Access-checked meeting notes for the anonymous share surface. Meeting access
+ * governs the payload; the linked transcript is an explicit, default-off part
+ * of that share and is omitted unless the meeting owner enables it.
+ */
+
+import { getSession, runWithRequestContext } from "@agent-native/core/server";
+import { resolveAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import {
+  defineEventHandler,
+  getQuery,
+  setResponseHeader,
+  setResponseStatus,
+} from "h3";
+
+import {
+  normalizeTranscriptSegments,
+  parseTranscriptSegments,
+} from "../../../shared/transcript-segments.js";
+import { resolveTranscriptPresentation } from "../../../shared/transcript-status.js";
+import { getDb, schema } from "../../db/index.js";
+
+interface Bullet {
+  text: string;
+}
+
+function parseBullets(raw: string | null | undefined): Bullet[] {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (bullet): bullet is Bullet =>
+        typeof bullet === "object" &&
+        bullet !== null &&
+        typeof bullet.text === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+export default defineEventHandler(async (event) => {
+  setResponseHeader(event, "Cache-Control", "private, max-age=0, no-store");
+  setResponseHeader(event, "Referrer-Policy", "no-referrer");
+
+  const query = getQuery(event);
+  const meetingId = typeof query.id === "string" ? query.id : "";
+  if (!meetingId) {
+    setResponseStatus(event, 400);
+    return { error: "id is required" };
+  }
+
+  const session = await getSession(event).catch(() => null);
+  const accessContext = {
+    userEmail: session?.email,
+    orgId: session?.orgId,
+  };
+
+  return runWithRequestContext(accessContext, async () => {
+    const access = await resolveAccess("meeting", meetingId, accessContext);
+    const meeting = access?.resource;
+    if (!meeting || meeting.trashedAt) {
+      setResponseStatus(event, 404);
+      return { error: "Not found" };
+    }
+
+    const db = getDb();
+    const [participants, actionItems, transcriptRows] = await Promise.all([
+      db
+        .select({
+          email: schema.meetingParticipants.email,
+          name: schema.meetingParticipants.name,
+          isOrganizer: schema.meetingParticipants.isOrganizer,
+        })
+        .from(schema.meetingParticipants)
+        .where(eq(schema.meetingParticipants.meetingId, meetingId)),
+      db
+        .select({
+          id: schema.meetingActionItems.id,
+          text: schema.meetingActionItems.text,
+          assigneeEmail: schema.meetingActionItems.assigneeEmail,
+          completedAt: schema.meetingActionItems.completedAt,
+        })
+        .from(schema.meetingActionItems)
+        .where(eq(schema.meetingActionItems.meetingId, meetingId)),
+      meeting.shareTranscript && meeting.recordingId
+        ? db
+            .select({
+              status: schema.recordingTranscripts.status,
+              language: schema.recordingTranscripts.language,
+              fullText: schema.recordingTranscripts.fullText,
+              failureReason: schema.recordingTranscripts.failureReason,
+              segmentsJson: schema.recordingTranscripts.segmentsJson,
+              updatedAt: schema.recordingTranscripts.updatedAt,
+            })
+            .from(schema.recordingTranscripts)
+            .where(
+              eq(schema.recordingTranscripts.recordingId, meeting.recordingId),
+            )
+            .limit(1)
+        : Promise.resolve([]),
+    ]);
+
+    const transcript = transcriptRows[0] ?? null;
+    const transcriptPresentation = resolveTranscriptPresentation(transcript);
+    const transcriptSegments = transcript
+      ? normalizeTranscriptSegments({
+          segments: parseTranscriptSegments(transcript.segmentsJson),
+          fullText: transcript.fullText,
+        })
+      : [];
+    const role = access.role;
+
+    return {
+      meeting: {
+        id: meeting.id,
+        title: meeting.title,
+        scheduledStart: meeting.scheduledStart,
+        actualStart: meeting.actualStart,
+        actualEnd: meeting.actualEnd,
+        transcriptStatus: meeting.transcriptStatus,
+        summaryMd: meeting.summaryMd,
+        bullets: parseBullets(meeting.bulletsJson),
+        participants,
+        actionItems,
+        ...(meeting.shareTranscript
+          ? {
+              transcript: transcript
+                ? {
+                    status: transcriptPresentation.status,
+                    language: transcript.language,
+                    fullText: transcript.fullText,
+                    segments: transcriptSegments,
+                  }
+                : null,
+            }
+          : {}),
+      },
+      viewer: session?.email
+        ? {
+            role,
+            canEdit: role === "owner" || role === "admin" || role === "editor",
+            isOwner: role === "owner",
+          }
+        : null,
+    };
+  });
+});

package/corpus/templates/clips/shared/agent-context.ts

@@ -13,6 +13,66 @@ export const AGENT_FRAME_ENDPOINT = "/api/agent-frame.jpg";
 export const CLIP_AGENT_ACCESS_TOKEN_PREFIX = "clip-agent-context";
 export const CLIPS_AGENT_ACCESS_PARAM = AGENT_ACCESS_PARAM || "agent_access";
 
+export type AgentClipReadiness = {
+  state: "preparing" | "ready" | "failed";
+  retryAfterSeconds: number | null;
+  instruction: string | null;
+};
+
+export function getAgentClipReadiness(
+  status: string | null | undefined,
+): AgentClipReadiness {
+  if (status === "uploading") {
+    return {
+      state: "preparing",
+      retryAfterSeconds: 15,
+      instruction:
+        "This clip is still uploading and is not ready to inspect. Wait 15 seconds, then fetch agentContextUrl again. Do not open the share page, request frames, or draw conclusions until clip.status is ready.",
+    };
+  }
+
+  if (status === "processing") {
+    return {
+      state: "preparing",
+      retryAfterSeconds: 15,
+      instruction:
+        "This clip is still processing and may still be transcoding or transcribing. Wait 15 seconds, then fetch agentContextUrl again. Do not open the share page, request frames, or draw conclusions until clip.status is ready.",
+    };
+  }
+
+  return {
+    state: status === "failed" ? "failed" : "ready",
+    retryAfterSeconds: null,
+    instruction: null,
+  };
+}
+
+export function buildAgentDiscoveryPayload({
+  recordingId,
+  title,
+  status,
+  agentContextUrl,
+}: {
+  recordingId: string;
+  title: string;
+  status: string | null | undefined;
+  agentContextUrl: string;
+}) {
+  const readiness = getAgentClipReadiness(status);
+  return {
+    type: "agent-native.clip.discovery",
+    version: CLIP_AGENT_CONTEXT_VERSION,
+    clipId: recordingId,
+    title,
+    recordingStatus: status ?? "unknown",
+    agentReadiness: readiness,
+    agentContextUrl,
+    instructions:
+      readiness.instruction ??
+      "Fetch agentContextUrl for the transcript and JPEG frame URLs. Fetch the frame URLs to SEE the screen, not just read the transcript.",
+  };
+}
+
 export function agentAccessTokenResourceId(recordingId: string): string {
   if (typeof scopedAgentAccessResourceId !== "function") {
     return `${CLIP_AGENT_ACCESS_TOKEN_PREFIX}:${recordingId}`;

package/corpus/templates/clips/shared/meeting-join-url.ts

@@ -0,0 +1,36 @@
+const ZOOM_JOIN_PATH = /^\/j\/(\d+)\/?$/;
+const ZOOM_WEB_CLIENT_JOIN_PATH = /^\/wc\/(\d+)\/join\/?$/;
+
+function isZoomMeetingHost(hostname: string): boolean {
+  return hostname === "zoom.us" || hostname.endsWith(".zoom.us");
+}
+
+/**
+ * Prefer Zoom's native URI when an HTTPS calendar link carries a meeting id.
+ * Other providers and URL shapes retain their original URL as the safe
+ * fallback.
+ */
+export function resolveNativeMeetingJoinUrl(joinUrl: string): string {
+  try {
+    const url = new URL(joinUrl);
+    if (url.protocol !== "https:" || !isZoomMeetingHost(url.hostname)) {
+      return joinUrl;
+    }
+
+    const meetingNumber =
+      ZOOM_JOIN_PATH.exec(url.pathname)?.[1] ??
+      ZOOM_WEB_CLIENT_JOIN_PATH.exec(url.pathname)?.[1];
+    if (!meetingNumber) return joinUrl;
+
+    const params = new URLSearchParams({
+      action: "join",
+      confno: meetingNumber,
+    });
+    const passcode = url.searchParams.get("pwd");
+    if (passcode) params.set("pwd", passcode);
+
+    return `zoommtg://${url.hostname}/join?${params.toString()}`;
+  } catch {
+    return joinUrl;
+  }
+}

package/dist/collab/routes.d.ts

@@ -26,8 +26,8 @@ export declare const getCollabState: import("h3").EventHandlerWithFetch<import("
  * Body: { update: string (base64), requestSource?: string }
  */
 export declare const postCollabUpdate: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    error: string;
     ok?: undefined;
+    error: string;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/file-upload/actions/upload-image.d.ts

@@ -17,12 +17,12 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
+    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
-    error?: undefined;
 }>;
 export default _default;
 //# sourceMappingURL=upload-image.d.ts.map

package/dist/notifications/routes.d.ts

@@ -13,13 +13,13 @@
 export declare function createNotificationsHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<"" | import("./types.js").Notification[] | {
     count: number;
     updated?: undefined;
-    ok?: undefined;
     error?: undefined;
+    ok?: undefined;
 } | {
     count?: undefined;
     updated: number;
-    ok?: undefined;
     error?: undefined;
+    ok?: undefined;
 } | {
     count?: undefined;
     updated?: undefined;

package/dist/progress/routes.d.ts

@@ -15,7 +15,7 @@ export declare function createProgressHandler(): import("h3").EventHandlerWithFe
     error: string;
     ok?: undefined;
 } | {
-    ok: boolean;
     error?: undefined;
+    ok: boolean;
 }>>;
 //# sourceMappingURL=routes.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.114.4",
+  "version": "0.114.5",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -380,7 +380,7 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.31",
     "zod": "^4.3.6",
-    "@agent-native/recap-cli": "0.4.4",
+    "@agent-native/recap-cli": "0.4.5",
     "@agent-native/toolkit": "^0.8.0"
   },
   "devDependencies": {