improvements

Author: icecrasher321

apps/sim/app/api/billing/member-credits/route.ts

@@ -0,0 +1,38 @@
+import { type NextRequest, NextResponse } from 'next/server'
+import { getMyMemberCreditsContract } from '@/lib/api/contracts/organization'
+import { parseRequest } from '@/lib/api/server'
+import { getSession } from '@/lib/auth'
+import { checkOrgMemberUsageLimit } from '@/lib/billing/calculations/usage-monitor'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+
+/**
+ * GET /api/billing/member-credits?workspaceId=...
+ *
+ * Returns the caller's OWN per-member usage and cap inside the workspace's
+ * organization, in DOLLARS (the DB unit) so the client's `formatCredits` does the
+ * single dollars→credits conversion. Own-data only, so no admin gate (unlike the
+ * org/member admin route). Reuses {@link checkOrgMemberUsageLimit}, which yields a
+ * null limit — and the chip falls back to the plan-level view — whenever no
+ * per-member cap applies: non-hosted, the workspace isn't org-owned, or no cap is
+ * set for this member.
+ */
+export const GET = withRouteHandler(async (request: NextRequest) => {
+  const session = await getSession()
+  if (!session?.user?.id) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  const parsed = await parseRequest(getMyMemberCreditsContract, request, {})
+  if (!parsed.success) return parsed.response
+
+  const { workspaceId } = parsed.data.query
+  const { currentUsage, limit } = await checkOrgMemberUsageLimit(session.user.id, workspaceId)
+
+  return NextResponse.json({
+    success: true,
+    data: {
+      usedDollars: currentUsage,
+      limitDollars: limit,
+    },
+  })
+})

apps/sim/app/api/speech/token/route.ts

@@ -155,6 +155,7 @@ export const POST = withRouteHandler(async (request: NextRequest) => {
           {
             error:
               usageCheck.message || 'Usage limit exceeded. Please upgrade your plan to continue.',
+            scope: usageCheck.scope,
           },
           { status: 402 }
         )

apps/sim/app/api/wand/route.ts

@@ -294,6 +294,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
           {
             success: false,
             error: usage.message || 'Usage limit exceeded. Please upgrade your plan to continue.',
+            scope: usage.scope,
           },
           { status: 402 }
         )

apps/sim/app/workspace/[workspaceId]/home/components/credits-chip/credits-chip.tsx

@@ -8,6 +8,7 @@ import { Credit } from '@/components/emcn/icons'
 import { ON_DEMAND_UNLIMITED } from '@/lib/billing/constants'
 import { formatCredits } from '@/lib/billing/credits/conversion'
 import { isBillingEnabled } from '@/app/workspace/[workspaceId]/settings/navigation'
+import { useMyMemberCredits } from '@/hooks/queries/organization'
 import { usePlanView } from '@/hooks/queries/plan-view'
 import { prefetchUpgradeBillingData, useSubscriptionData } from '@/hooks/queries/subscription'
 import { prefetchWorkspaceSettings } from '@/hooks/queries/workspace'
@@ -30,6 +31,7 @@ function CreditsChipInner() {
   const router = useRouter()
   const queryClient = useQueryClient()
   const { workspaceId } = useParams<{ workspaceId: string }>()
+  const { data: memberCredits } = useMyMemberCredits(workspaceId)
 
   const upgradeHref = `/workspace/${workspaceId}/upgrade`
 
@@ -43,6 +45,29 @@ function CreditsChipInner() {
     prefetchWorkspaceSettings(queryClient, workspaceId)
   }, [router, queryClient, upgradeHref, workspaceId])
 
+  const renderChip = (dollars: number) => (
+    <Chip
+      aria-label='Credits remaining — upgrade plan'
+      onClick={() => router.push(upgradeHref)}
+      onMouseEnter={prefetchUpgrade}
+      onFocus={prefetchUpgrade}
+      leftIcon={Credit}
+    >
+      {formatCredits(dollars)}
+    </Chip>
+  )
+
+  /**
+   * A per-member org credit cap is the authoritative personal remaining for this
+   * member — show it even when the plan-based chip would otherwise be hidden (e.g.
+   * external members). Values are dollars (the chip formats via `formatCredits`),
+   * clamped at 0 so an over-cap member never sees a negative.
+   */
+  const limitDollars = memberCredits?.limitDollars ?? null
+  if (limitDollars !== null) {
+    return renderChip(Math.max(0, limitDollars - (memberCredits?.usedDollars ?? 0)))
+  }
+
   if (isLoading || !hasData || !data?.data) return null
   if (!planView.showCredits) return null
 
@@ -58,15 +83,5 @@ function CreditsChipInner() {
       ? ON_DEMAND_UNLIMITED
       : Math.max(0, usageLimit + creditBalance - currentUsage)
 
-  return (
-    <Chip
-      aria-label='Credits remaining — upgrade plan'
-      onClick={() => router.push(upgradeHref)}
-      onMouseEnter={prefetchUpgrade}
-      onFocus={prefetchUpgrade}
-      leftIcon={Credit}
-    >
-      {formatCredits(remainingCredits)}
-    </Chip>
-  )
+  return renderChip(remainingCredits)
 }

apps/sim/app/workspace/[workspaceId]/home/components/user-input/user-input.tsx

@@ -13,7 +13,7 @@ import {
 } from 'react'
 import { createLogger } from '@sim/logger'
 import { useParams } from 'next/navigation'
-import { Button, Paperclip, Slash, Tooltip } from '@/components/emcn'
+import { Button, Paperclip, Slash, Tooltip, toast } from '@/components/emcn'
 import { getMothershipAttachmentPreviewUrl } from '@/lib/copilot/chat/attachment-preview'
 import { SIM_RESOURCE_DRAG_TYPE, SIM_RESOURCES_DRAG_TYPE } from '@/lib/copilot/resource-types'
 import { cn } from '@/lib/core/utils/cn'
@@ -392,8 +392,20 @@ export const UserInput = forwardRef<UserInputHandle, UserInputProps>(function Us
     valueRef.current = converted
   }
 
-  function handleUsageLimitExceeded() {
-    navigateToSettings({ section: 'billing' })
+  function handleUsageLimitExceeded(message?: string, isMemberLimit?: boolean) {
+    // A per-member cap can only be raised by an org admin, so don't offer Upgrade
+    // (the member can't act on it) — the message already tells them to ask an admin.
+    toast.error(
+      message || 'You are out of credits.',
+      isMemberLimit
+        ? undefined
+        : {
+            action: {
+              label: 'Upgrade',
+              onClick: () => navigateToSettings({ section: 'billing' }),
+            },
+          }
+    )
   }
 
   const {

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/hooks/use-wand.ts

@@ -245,12 +245,20 @@ export function useWand({
         if (error.name === 'AbortError') {
           logger.debug('Wand generation cancelled')
         } else if (isApiClientError(error) && error.status === 402) {
-          toast.error(error.message || 'Usage limit reached', {
-            action: {
-              label: 'Upgrade',
-              onClick: () => navigateToSettings({ section: 'billing' }),
-            },
-          })
+          // A per-member cap is only raisable by an org admin, so skip the Upgrade
+          // affordance the member can't act on.
+          const isMemberLimit = (error.body as { scope?: string } | null)?.scope === 'member'
+          toast.error(
+            error.message || 'Usage limit reached',
+            isMemberLimit
+              ? undefined
+              : {
+                  action: {
+                    label: 'Upgrade',
+                    onClick: () => navigateToSettings({ section: 'billing' }),
+                  },
+                }
+          )
         } else {
           logger.error('Wand generation failed', { error })
           setError(error.message || 'Generation failed')

apps/sim/hooks/queries/organization.ts

@@ -16,10 +16,12 @@ import {
 } from '@/lib/api/contracts/invitations'
 import {
   createOrganizationContract,
+  getMyMemberCreditsContract,
   getOrganizationMemberUsageLimitContract,
   getOrganizationRosterContract,
   inviteOrganizationMembersContract,
   listOrganizationMembersContract,
+  type MyMemberCreditsData,
   type OrganizationMembersResponse,
   type OrganizationMemberUsageLimitData,
   type OrganizationRoster,
@@ -107,6 +109,8 @@ export const organizationKeys = {
   memberUsageLimit: (id: string, userId: string) =>
     [...organizationKeys.detail(id), 'member-usage-limit', userId] as const,
   roster: (id: string) => [...organizationKeys.detail(id), 'roster'] as const,
+  myMemberCredits: (workspaceId: string) =>
+    [...organizationKeys.all, 'my-member-credits', workspaceId] as const,
 }
 
 export type { OrganizationRoster, RosterMember, RosterPendingInvitation, RosterWorkspaceAccess }
@@ -540,6 +544,31 @@ export function useUpdateOrganizationMemberUsageLimit() {
   })
 }
 
+async function fetchMyMemberCredits(
+  workspaceId: string,
+  signal?: AbortSignal
+): Promise<MyMemberCreditsData> {
+  const response = await requestJson(getMyMemberCreditsContract, {
+    query: { workspaceId },
+    signal,
+  })
+  return response.data
+}
+
+/**
+ * The caller's OWN per-member credit usage + cap for a workspace's organization.
+ * `creditLimit` is null when no per-member cap applies (non-hosted, non-org
+ * workspace, or no cap set) — callers then fall back to the plan-level view.
+ */
+export function useMyMemberCredits(workspaceId?: string) {
+  return useQuery({
+    queryKey: organizationKeys.myMemberCredits(workspaceId ?? ''),
+    queryFn: ({ signal }) => fetchMyMemberCredits(workspaceId as string, signal),
+    enabled: Boolean(workspaceId),
+    staleTime: 30 * 1000,
+  })
+}
+
 type TransferOwnershipParams = {
   orgId: string
 } & ContractBodyInput<typeof transferOwnershipContract>

apps/sim/hooks/use-speech-to-text.ts

@@ -20,7 +20,11 @@ export type PermissionState = 'prompt' | 'granted' | 'denied'
 
 interface UseSpeechToTextProps {
   onTranscript: (text: string) => void
-  onUsageLimitExceeded?: () => void
+  /**
+   * Called on a 402 from the token endpoint, with the server's limit message and
+   * whether it was a per-member cap (which only an org admin can raise).
+   */
+  onUsageLimitExceeded?: (message?: string, isMemberLimit?: boolean) => void
   language?: string
   /** Attributes the voice-input cost to this workspace for per-member usage. */
   workspaceId?: string
@@ -176,7 +180,8 @@ export function useSpeechToText({
         })
       } catch (err) {
         if (isApiClientError(err) && err.status === 402) {
-          onUsageLimitExceededRef.current?.()
+          const isMemberLimit = (err.body as { scope?: string } | null)?.scope === 'member'
+          onUsageLimitExceededRef.current?.(err.message, isMemberLimit)
           return false
         }
         throw err instanceof Error ? err : new Error('Failed to get speech token')

apps/sim/lib/api/contracts/organization.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod'
+import { workspaceIdSchema } from '@/lib/api/contracts/primitives'
 import { organizationBillingDataSchema } from '@/lib/api/contracts/subscription'
 import { defineRouteContract } from '@/lib/api/contracts/types'
 import { workspacePermissionSchema } from '@/lib/api/contracts/workspaces'
@@ -408,6 +409,37 @@ export const updateOrganizationMemberUsageLimitContract = defineRouteContract({
   },
 })
 
+/**
+ * Self-service per-member usage for the chat-home credits chip. Values are in
+ * DOLLARS (the DB unit) so the client's `formatCredits` performs the single
+ * dollars→credits conversion — returning credits here would double-convert.
+ * `limitDollars` is null when no per-member cap applies (non-hosted, the
+ * workspace isn't org-owned, or no cap is set), so the chip falls back to the
+ * plan-level credits view.
+ */
+export const myMemberCreditsDataSchema = z.object({
+  usedDollars: z.number(),
+  limitDollars: z.number().nullable(),
+})
+export type MyMemberCreditsData = z.infer<typeof myMemberCreditsDataSchema>
+
+/**
+ * Own-data-only (no admin gate, unlike the admin route above) and workspace-
+ * scoped, so the chat-home chip can resolve the acting member's own remaining.
+ */
+export const getMyMemberCreditsContract = defineRouteContract({
+  method: 'GET',
+  path: '/api/billing/member-credits',
+  query: z.object({ workspaceId: workspaceIdSchema }),
+  response: {
+    mode: 'json',
+    schema: z.object({
+      success: z.boolean(),
+      data: myMemberCreditsDataSchema,
+    }),
+  },
+})
+
 export const transferOwnershipContract = defineRouteContract({
   method: 'POST',
   path: '/api/organizations/[id]/transfer-ownership',

apps/sim/lib/billing/calculations/usage-monitor.ts

@@ -499,21 +499,23 @@ export async function checkOrgMemberUsageLimit(
  * ({@link checkOrgMemberUsageLimit}) when a workspace is in scope. Returns the
  * first exceeded result so every billable surface (workflow exec, copilot,
  * voice, wand, enrichment, KB indexing) can gate on a single
- * `{ isExceeded, message }` and surface the same message.
+ * `{ isExceeded, message }`. `scope` distinguishes a pooled cap from a per-member
+ * cap so clients can hide an "Upgrade" affordance a capped member can't act on (a
+ * per-member cap is only raisable by an org admin).
  */
 export async function checkActorUsageLimits(
   userId: string,
   workspaceId?: string | null
-): Promise<{ isExceeded: boolean; message?: string }> {
+): Promise<{ isExceeded: boolean; message?: string; scope?: 'pooled' | 'member' }> {
   const pooled = await checkServerSideUsageLimits(userId)
   if (pooled.isExceeded) {
-    return { isExceeded: true, message: pooled.message }
+    return { isExceeded: true, message: pooled.message, scope: 'pooled' }
   }
 
   if (workspaceId) {
     const member = await checkOrgMemberUsageLimit(userId, workspaceId)
     if (member.isExceeded) {
-      return { isExceeded: true, message: member.message }
+      return { isExceeded: true, message: member.message, scope: 'member' }
     }
   }