akanjs 3.0.0-beta.0 → 3.0.0-beta.2

package/types/ui/Agent/Composer.d.ts

@@ -5,6 +5,8 @@ export interface ComposerProps {
     session: AgentSession;
     draft: string;
     attached: readonly MessageAttachment[];
+    /** Files still being read. An `attach` that uploads takes seconds, and a panel that shows nothing looks broken. */
+    pending?: number;
     /** Absent when the screen cannot listen — the same rule as publishing no tool for a control that is not drawn. */
     mic?: {
         listening: boolean;
@@ -19,5 +21,5 @@ export interface ComposerProps {
     inputRef?: RefObject<HTMLTextAreaElement | null>;
 }
 /** What the user writes with: the staged files above, and the controls that send or stop below them. */
-export declare const DefaultComposer: ({ className, session, draft, attached, mic, onDraft, onKeyDown, onFiles, onRemoveFile, onSend, onStop, inputRef, }: ComposerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const DefaultComposer: ({ className, session, draft, attached, pending, mic, onDraft, onKeyDown, onFiles, onRemoveFile, onSend, onStop, inputRef, }: ComposerProps) => import("react/jsx-runtime").JSX.Element;
 export declare const Composer: import("react").ComponentType<ComposerProps>;

package/types/ui/Agent/useChatAttachments.d.ts

@@ -14,6 +14,7 @@ interface ChatAttachmentsSetup {
  */
 export declare const useChatAttachments: ({ session, attach, limits, l }: ChatAttachmentsSetup) => {
     attached: MessageAttachment[];
+    pending: number;
     dragging: boolean;
     dropProps: {
         [key: string]: DragEventHandler<HTMLElement>;

package/types/vendor/use-agentic/types.d.ts

@@ -114,6 +114,12 @@ export interface ToolCallResult {
  * model cannot read and says so in the transcript, because a silently dropped file is one the model then
  * hallucinates about.
  */
+/**
+ * Why an assistant turn ended. `length` is the provider's own ceiling rather than the model's choice, so the turn
+ * is incomplete — a truncated answer and a turn cut off before its tool call finished both arrive this way, and
+ * neither is distinguishable from `end` without it.
+ */
+export type TurnStop = "end" | "toolUse" | "length";
 export interface MessageAttachment {
     name: string;
     mimeType: string;
@@ -165,7 +171,7 @@ export type RunnerEvent = {
     args: Record<string, unknown>;
 } | {
     type: "done";
-    stop: "end" | "toolUse";
+    stop: TurnStop;
 }
 /**
  * `data` accompanies a message that is a code rather than a sentence — the values whoever resolves the code

package/ui/Agent/Attach.tsx

@@ -44,9 +44,12 @@ interface ChipsProps {
   /** Omitted for a sent message: what is already on the wire cannot be taken back. */
   onRemove?: (index: number) => void;
   removeLabel?: string;
+  /** Files still being read, standing beside the ones that are staged so the panel is never blank mid-drop. */
+  pending?: number;
+  pendingLabel?: string;
 }
 
-export const Chips = ({ className, attachments, onRemove, removeLabel }: ChipsProps) => (
+export const Chips = ({ className, attachments, onRemove, removeLabel, pending = 0, pendingLabel }: ChipsProps) => (
   <div className={cn("flex flex-wrap gap-1", className)}>
     {attachments.map((attachment, idx) => (
       <span
@@ -73,5 +76,14 @@ export const Chips = ({ className, attachments, onRemove, removeLabel }: ChipsPr
         ) : null}
       </span>
     ))}
+    {Array.from({ length: pending }, (_, idx) => (
+      <span
+        className="flex animate-pulse items-center gap-1 rounded-field bg-muted px-2 py-0.5 text-foreground/50 text-xs"
+        key={`pending-${idx}`}
+      >
+        <AiOutlinePaperClip />
+        <span className="max-w-32 truncate">{pendingLabel}</span>
+      </span>
+    ))}
   </div>
 );

package/ui/Agent/Chat.tsx

@@ -498,6 +498,7 @@ export const DefaultChat = ({
       <Menu onPick={(row) => row.pick()} rows={menu.rows} selected={menu.selected} />
       <Composer
         attached={files.attached}
+        pending={files.pending}
         draft={draft}
         inputRef={inputRef}
         {...(speech.canListen ? { mic: { listening: speech.listening, onToggle: speech.toggle } } : {})}

package/ui/Agent/Composer.tsx

@@ -13,6 +13,8 @@ export interface ComposerProps {
   session: AgentSession;
   draft: string;
   attached: readonly MessageAttachment[];
+  /** Files still being read. An `attach` that uploads takes seconds, and a panel that shows nothing looks broken. */
+  pending?: number;
   /** Absent when the screen cannot listen — the same rule as publishing no tool for a control that is not drawn. */
   mic?: { listening: boolean; onToggle: () => void };
   onDraft: (text: string) => void;
@@ -33,6 +35,7 @@ export const DefaultComposer = ({
   session,
   draft,
   attached,
+  pending = 0,
   mic,
   onDraft,
   onKeyDown,
@@ -53,8 +56,14 @@ export const DefaultComposer = ({
   }, [draft, inputRef]);
   return (
     <div className={cn("flex flex-col gap-2 border-foreground/5 border-t p-3", className)}>
-      {attached.length ? (
-        <Chips attachments={attached} onRemove={onRemoveFile} removeLabel={l("base.agentAttachRemove")} />
+      {attached.length || pending ? (
+        <Chips
+          attachments={attached}
+          onRemove={onRemoveFile}
+          pending={pending}
+          pendingLabel={l("base.agentAttachReading")}
+          removeLabel={l("base.agentAttachRemove")}
+        />
       ) : null}
       <div className="flex items-end gap-2">
         {mic ? (

package/ui/Agent/useChatAttachments.ts

@@ -25,6 +25,8 @@ export const useChatAttachments = ({ session, attach, limits = {}, l }: ChatAtta
   const count = limits.perMessageCount ?? maxMessageAttachments;
   const messageBytes = limits.perMessageBytes ?? maxMessageAttachmentBytes;
   const [attached, setAttached] = useState<MessageAttachment[]>([]);
+
+  const [pending, setPending] = useState(0);
   const [dragging, setDragging] = useState(false);
   const staged = useRef<MessageAttachment[]>([]);
   
@@ -45,6 +47,7 @@ export const useChatAttachments = ({ session, attach, limits = {}, l }: ChatAtta
         session.note(l("base.agentAttachTooMany", { count }));
         return;
       }
+      setPending((waiting) => waiting + 1);
       try {
         const read = await Attachment.read(file, attach, limits);
         if (Attachment.failure(read))
@@ -58,6 +61,8 @@ export const useChatAttachments = ({ session, attach, limits = {}, l }: ChatAtta
         else stage([...staged.current, read]);
       } catch (error) {
         session.report(`${file.name}: ${error instanceof Error ? error.message : String(error)}`);
+      } finally {
+        setPending((waiting) => Math.max(0, waiting - 1));
       }
     }
   };
@@ -94,6 +99,7 @@ export const useChatAttachments = ({ session, attach, limits = {}, l }: ChatAtta
   };
   return {
     attached,
+    pending,
     dragging,
     dropProps,
     add,

package/vendor/use-agentic/AgentSession.ts

@@ -12,6 +12,7 @@ import type {
   SurfaceView,
   ToolCallRequest,
   ToolCallResult,
+  TurnStop,
 } from "./types";
 
 export interface PendingApproval {
@@ -264,6 +265,15 @@ export class AgentSession {
           this.#unanswered(toolCalls);
           return;
         }
+
+        if (stop === "length") {
+
+          this.#fail(
+            "The model ran out of room mid-answer, so this turn is incomplete. Ask again, or raise the answer limit.",
+          );
+          if (toolCalls.length) this.#unanswered(toolCalls);
+          return;
+        }
         if (stop !== "toolUse" || !toolCalls.length) return;
         const toolResults: ToolCallResult[] = [];
         for (const call of toolCalls)
@@ -478,7 +488,7 @@ export class AgentSession {
     return text;
   }
 
-  async #assistantTurn(signal: AbortSignal): Promise<{ toolCalls: ToolCallRequest[]; stop: "end" | "toolUse" }> {
+  async #assistantTurn(signal: AbortSignal): Promise<{ toolCalls: ToolCallRequest[]; stop: TurnStop }> {
     const { tools, guides } = this.#surface.snapshot();
     const instructions = [this.#options.instructions, ...guides].filter(Boolean).join("\n\n");
     const request: RunnerRequest = {
@@ -493,7 +503,7 @@ export class AgentSession {
     this.#append({ role: "assistant" });
     let text = "";
     const toolCalls: ToolCallRequest[] = [];
-    let stop: "end" | "toolUse" = "end";
+    let stop: TurnStop = "end";
     for await (const event of this.#runner.run(request)) {
       if (signal.aborted) break;
       if (event.type === "text") {

package/vendor/use-agentic/WIRE.md

@@ -44,7 +44,7 @@ tools, and the loop stay in the client; the server serves exactly one stateless
 ## Attachments
 
 A message may carry files in `attachments` (`MessageAttachment`, `types.ts`) — one of `data` (base64 bytes), `url`,
-or `text` (already-extracted content), plus `name` and `mimeType`:
+or `text` (already-extracted content), plus `name` and `mimeType`, and an optional `ref`:
 
 ```jsonc
 { "role": "user", "text": "What does this chart say?",
@@ -57,6 +57,11 @@ it with a note in the message text saying which file was not read and why, so th
 another form. `text` is readable by every provider by definition, which is what makes an extracted PDF work against
 a text-only model.
 
+`ref` is the host's own handle on the file — a file id, a storage key — opaque to everything in between. A backend
+carries it and never reads it; it is not shown to the model, and a tool the host published is what spends it.
+Without one, a host that stores its uploads has to identify a file by name and size, which collides for two crops
+of one export.
+
 Nothing here is stored: the wire carries the bytes for exactly one turn's request.
 
 ## Response

package/vendor/use-agentic/httpRunner.ts

@@ -10,7 +10,7 @@ export interface HttpRunnerOptions {
 interface TurnAnswer {
   text?: string;
   toolCalls?: ToolCallRequest[];
-  stop?: "end" | "toolUse";
+  stop?: "end" | "toolUse" | "length";
 }
 
 const eventTypes = new Set(["text", "toolCall", "done", "error"]);

package/vendor/use-agentic/types.ts

@@ -131,6 +131,13 @@ export interface ToolCallResult {
  * model cannot read and says so in the transcript, because a silently dropped file is one the model then
  * hallucinates about.
  */
+/**
+ * Why an assistant turn ended. `length` is the provider's own ceiling rather than the model's choice, so the turn
+ * is incomplete — a truncated answer and a turn cut off before its tool call finished both arrive this way, and
+ * neither is distinguishable from `end` without it.
+ */
+export type TurnStop = "end" | "toolUse" | "length";
+
 export interface MessageAttachment {
   name: string;
   mimeType: string;
@@ -178,7 +185,7 @@ export interface ContextBlock {
 export type RunnerEvent =
   | { type: "text"; delta: string }
   | { type: "toolCall"; id: string; name: string; args: Record<string, unknown> }
-  | { type: "done"; stop: "end" | "toolUse" }
+  | { type: "done"; stop: TurnStop }
   /**
    * `data` accompanies a message that is a code rather than a sentence — the values whoever resolves the code
    * interpolates into its text. A host that does not know the code shows the message as it stands.